Merge branch 'feature/fe_tests_reducers' of Neca/HRCenter into FE_dev

src/__tests__/ReduxTests/Reducers/addAddTechnologiesReducer.test.js

+import reducer from "../../../store/reducers/technology/addAddTechnologiesReducer";
+import expect from "expect";
+import {
+  changeIsCheckedAddAdValue,
+  resetIsCheckedAddAdValue,
+  setTechnologiesAddAd,
+  setTechnologiesAddAdError,
+} from "../../../store/actions/addAdTechnologies/addAdTechnologiesActions";
+
+describe("ad technologies reducer", () => {
+  it("should set techologies", () => {
+    expect(
+      reducer(undefined, setTechnologiesAddAd(["tech1", "tech2"]))
+    ).toEqual({
+      technologies: ["tech1", "tech2"],
+      errorMessage: "",
+    });
+  });
+
+  it("should set error", () => {
+    expect(reducer(undefined, setTechnologiesAddAdError("Error"))).toEqual({
+      technologies: [],
+      errorMessage: "Error",
+    });
+  });
+
+  it("should check tech", () => {
+    expect(
+      reducer(
+        {
+          technologies: [
+            { technologyId: 1, name: "T1", isChecked: false },
+            { technologyId: 2, name: "T2", isChecked: false },
+          ],
+          errorMessage: "",
+        },
+        changeIsCheckedAddAdValue(1)
+      )
+    ).toEqual({
+      technologies: [
+        { technologyId: 1, name: "T1", isChecked: true },
+        { technologyId: 2, name: "T2", isChecked: false },
+      ],
+      errorMessage: "",
+    });
+  });
+
+  it("should reset checked tech", () => {
+    expect(
+      reducer(
+        {
+          technologies: [
+            { technologyId: 1, name: "T1", isChecked: true },
+            { technologyId: 2, name: "T2", isChecked: true },
+          ],
+          errorMessage: "",
+        },
+        resetIsCheckedAddAdValue()
+      )
+    ).toEqual({
+      technologies: [
+        { technologyId: 1, name: "T1", isChecked: false },
+        { technologyId: 2, name: "T2", isChecked: false },
+      ],
+      errorMessage: "",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/inviteUserReducer.test.js

+import reducer from "../../../store/reducers/user/inviteUserReducer";
+import expect from "expect";
+import { inviteUserError, inviteUserSuccess } from "../../../store/actions/users/usersActions";
+
+describe("invite user reducer", () => {
+  it("should return the initial state", () => {
+    expect(reducer(undefined, {})).toEqual({
+      isSuccess: false,
+      errorMessage: "",
+    });
+  });
+
+  it("should set the state error", () => {
+    expect(reducer(undefined, inviteUserError("Error"))).toEqual({
+      isSuccess: false,
+      errorMessage: "Error",
+    });
+  });
+
+  it("should set the state success", () => {
+    expect(reducer(undefined, inviteUserSuccess())).toEqual({
+      isSuccess: true,
+      errorMessage: "",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/registerReducer.test.js

+import reducer from "../../../store/reducers/register/registerReducer";
+import expect from "expect";
+import {
+  registerError,
+  registerSuccess,
+} from "../../../store/actions/register/registerActions";
+
+describe("register reducer", () => {
+  it("should set success", () => {
+    expect(reducer(undefined, registerSuccess())).toEqual({
+      isSuccess: true,
+      errorMessage: "",
+    });
+  });
+
+  it("should set error", () => {
+    expect(reducer(undefined, registerError("Error"))).toEqual({
+      isSuccess: false,
+      errorMessage: "Error",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/scheduleReducer.test.js

+import reducer from "../../../store/reducers/schedule/scheduleReducer";
+import expect from "expect";
+import {
+  fetchScheduleError,
+  fetchScheduleSuccess,
+} from "../../../store/actions/schedule/scheduleActions";
+
+describe("schedule reducer", () => {
+  it("should set schedule", () => {
+    expect(reducer(undefined, fetchScheduleSuccess(["1", "2"]))).toEqual({
+      schedule: ["1", "2"],
+      errorMessage: "",
+    });
+  });
+
+  it("should set error", () => {
+    expect(reducer(undefined, fetchScheduleError("Error"))).toEqual({
+      schedule: [],
+      errorMessage: "Error",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/screeningTestsReducer.test.js

+import reducer from "../../../store/reducers/screeningTests/screeningTestsReducer";
+import expect from "expect";
+import { fetchScreeningTestsError, fetchScreeningTestsSuccess } from "../../../store/actions/screeningTests/screeningTestActions";
+
+describe("screening tests reducer", () => {
+  it("should set tests", () => {
+    expect(
+      reducer(undefined, fetchScreeningTestsSuccess(["test1", "test2"]))
+    ).toEqual({
+      screeningTests: ["test1", "test2"],
+      errorMessage: "",
+    });
+  });
+
+  it("should set error", () => {
+    expect(reducer(undefined, fetchScreeningTestsError("Error"))).toEqual({
+      screeningTests: [],
+      errorMessage: "Error",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/statsReducer.test.js

+import reducer from "../../../store/reducers/stats/statsReducer";
+import expect from "expect";
+import {
+  getStatsError,
+  getStatsSuccess,
+} from "../../../store/actions/stats/statsActions";
+
+describe("stats reducer", () => {
+  it("should return the initial state", () => {
+    expect(reducer(undefined, {})).toEqual({
+      fetchStatsErrorMessage: "",
+      stats: {},
+    });
+  });
+
+  it("should set error message", () => {
+    expect(reducer(undefined, getStatsError("Error"))).toEqual({
+      stats: {},
+      fetchStatsErrorMessage: "Error",
+    });
+  });
+
+  it("Should set state stats", () => {
+    expect(reducer(undefined, getStatsSuccess({ data: "mockData" }))).toEqual({
+      stats: { data: "mockData" },
+      fetchStatsErrorMessage: "",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/statusUpdateReducer.test.js

+import reducer from "../../../store/reducers/processes/statusUpdateReducer";
+import expect from "expect";
+import {
+  registerError,
+  registerSuccess,
+} from "../../../store/actions/register/registerActions";
+import {
+  setUpdateStatusErr,
+  setUpdateStatusReq,
+  setUpdateStatusSucc,
+} from "../../../store/actions/processes/processAction";
+
+describe("status update reducer", () => {
+  it("should set success", () => {
+    expect(reducer(undefined, setUpdateStatusSucc())).toEqual({
+      success: true,
+      errorMessage: "",
+    });
+  });
+
+  it("should set error", () => {
+    expect(reducer(undefined, setUpdateStatusErr("Error"))).toEqual({
+      success: false,
+      errorMessage: "Error",
+    });
+  });
+
+  it("should set error", () => {
+    expect(reducer(undefined, setUpdateStatusReq("any"))).toEqual({
+      success: false,
+      errorMessage: "",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/technologiesReducer.test.js

+import reducer from "../../../store/reducers/technology/technologiesReducer";
+import expect from "expect";
+import {
+  changeIsCheckedValue,
+  resetIsCheckedValue,
+  setTechnologies,
+  setTechnologiesError,
+} from "../../../store/actions/technologies/technologiesActions";
+
+describe("technologies reducer", () => {
+  it("should set techologies", () => {
+    expect(reducer(undefined, setTechnologies(["tech1", "tech2"]))).toEqual({
+      technologies: ["tech1", "tech2"],
+      errorMessage: "",
+    });
+  });
+
+  it("should set error", () => {
+    expect(reducer(undefined, setTechnologiesError("Error"))).toEqual({
+      technologies: [],
+      errorMessage: "Error",
+    });
+  });
+
+  it("should check tech", () => {
+    expect(
+      reducer(
+        {
+          technologies: [
+            { id: 1, name: "T1", isChecked: false },
+            { id: 2, name: "T2", isChecked: false },
+          ],
+          errorMessage: "",
+        },
+        changeIsCheckedValue("T1")
+      )
+    ).toEqual({
+      technologies: [
+        { id: 1, name: "T1", isChecked: true },
+        { id: 2, name: "T2", isChecked: false },
+      ],
+      errorMessage: "",
+    });
+  });
+
+  it("should reset checked techs", () => {
+    expect(
+      reducer(
+        {
+          technologies: [
+            { id: 1, name: "T1", isChecked: true },
+            { id: 2, name: "T2", isChecked: true },
+          ],
+          errorMessage: "",
+        },
+        resetIsCheckedValue("T1")
+      )
+    ).toEqual({
+      technologies: [
+        { id: 1, name: "T1", isChecked: false },
+        { id: 2, name: "T2", isChecked: false },
+      ],
+      errorMessage: "",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/userDetailsReducer.test.js

+import reducer from "../../../store/reducers/user/userDetailsReducer";
+import expect from "expect";
+import {
+  stateUserDetailsSuccess,
+  toggleSingleUser,
+  userDetailsError,
+} from "../../../store/actions/users/usersActions";
+
+describe("user reducer", () => {
+  it("should return the initial state", () => {
+    expect(reducer(undefined, {})).toEqual({
+      user: {},
+      errorMessage: "",
+    });
+  });
+
+  it("should set the state user error", () => {
+    expect(reducer(undefined, userDetailsError("Error"))).toEqual({
+      user: {},
+      errorMessage: "Error",
+    });
+  });
+
+  it("should set the state user", () => {
+    expect(
+      reducer(undefined, stateUserDetailsSuccess({ name: "User" }))
+    ).toEqual({
+      user: { name: "User" },
+      errorMessage: "",
+    });
+  });
+});
+
+it("should set the state user", () => {
+  expect(
+    reducer(
+      {
+        user: { name: "User", isEnabled: true },
+        errorMessage: "",
+      },
+      toggleSingleUser()
+    )
+  ).toEqual({
+    user: { name: "User", isEnabled: false },
+    errorMessage: "",
+  });
+});

src/__tests__/ReduxTests/Reducers/userReducer.test.js

+import reducer from "../../../store/reducers/user/userReducer";
+import expect from "expect";
+import {
+  resetUserState,
+  setUser,
+  setUserError,
+} from "../../../store/actions/user/userActions";
+
+describe("invite user reducer", () => {
+  it("should set the state user", () => {
+    expect(reducer(undefined, setUser({ username: "username" }))).toEqual({
+      user: {
+        username: "username",
+      },
+      errorMessage: "",
+    });
+  });
+
+  it("should reset the state", () => {
+    expect(reducer(undefined, resetUserState())).toEqual({
+      user: {
+        id: "",
+        firstName: "",
+        lastName: "",
+        username: "",
+        token: "",
+        refreshToken: "",
+      },
+      errorMessage: "",
+    });
+  });
+
+  it("should set the state error", () => {
+    expect(reducer(undefined, setUserError('Error'))).toEqual({
+      user: {
+        id: "",
+        firstName: "",
+        lastName: "",
+        username: "",
+        token: "",
+        refreshToken: "",
+      },
+      errorMessage: "Error",
+    });
+  });
+});

src/__tests__/ReduxTests/Reducers/usersReducer.test.js

+import reducer from "../../../store/reducers/user/usersReducer";
+import expect from "expect";
+import {
+  deleteStateUser,
+  deleteUserError,
+  setEnableUsers,
+  setEnableUsersError,
+  setUsers,
+  setUsersError,
+} from "../../../store/actions/users/usersActions";
+
+describe("users reducer", () => {
+  it("should return the initial state", () => {
+    expect(reducer(undefined, {})).toEqual({
+      fetchUsersErrorMessage: "",
+      selected: {},
+      toggleEnableErrorMessage: "",
+      users: [],
+    });
+  });
+
+  it("should set error message", () => {
+    expect(reducer(undefined, setUsersError("Error"))).toEqual({
+      fetchUsersErrorMessage: "Error",
+      selected: {},
+      toggleEnableErrorMessage: "",
+      users: [],
+    });
+  });
+
+  it("Should set state users", () => {
+    expect(reducer(undefined, setUsers(["user1", "user2"]))).toEqual({
+      fetchUsersErrorMessage: "",
+      selected: {},
+      toggleEnableErrorMessage: "",
+      users: ["user1", "user2"],
+    });
+  });
+
+  it("should set enable toggle error message", () => {
+    expect(reducer(undefined, setEnableUsersError("Error"))).toEqual({
+      fetchUsersErrorMessage: "",
+      selected: {},
+      toggleEnableErrorMessage: "Error",
+      users: [],
+    });
+  });
+
+  it("should toogle enable on specific user", () => {
+    expect(
+      reducer(
+        {
+          fetchUsersErrorMessage: "",
+          selected: {},
+          toggleEnableErrorMessage: "",
+          users: [
+            { id: 1, name: "User1", isEnabled: true },
+            { id: 2, name: "User2", isEnabled: true },
+          ],
+        },
+        setEnableUsers(1)
+      )
+    ).toEqual({
+      fetchUsersErrorMessage: "",
+      selected: {},
+      toggleEnableErrorMessage: "",
+      users: [
+        { id: 1, name: "User1", isEnabled: false },
+        { id: 2, name: "User2", isEnabled: true },
+      ],
+    });
+  });
+
+  it("should set delete user error message", () => {
+    expect(reducer(undefined, deleteUserError("Error"))).toEqual({
+      fetchUsersErrorMessage: "",
+      selected: {},
+      toggleEnableErrorMessage: "Error",
+      users: [],
+    });
+  });
+
+  it("should delete specific user", () => {
+    expect(
+      reducer(
+        {
+          fetchUsersErrorMessage: "",
+          selected: {},
+          toggleEnableErrorMessage: "",
+          users: [
+            { id: 1, name: "User1", isEnabled: true },
+            { id: 2, name: "User2", isEnabled: true },
+          ],
+        },
+        deleteStateUser(1)
+      )
+    ).toEqual({
+      fetchUsersErrorMessage: "",
+      selected: {},
+      toggleEnableErrorMessage: "",
+      users: [{ id: 2, name: "User2", isEnabled: true }],
+    });
+  });
+});