frontend-apps/users-manage/tests/services/serviceOfUsers/serviceOfUsers.test.js

import {expect, test, describe, vi, beforeEach} from "vitest"
import AdapterOfUsers from '@adapters/adapterOfUsers/Users'
import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
import {
  addedUser, 
  getUserById,
  usersWithThisService,
  usersWithoutThisService,
  addServiceIdToUser, 
  deleteServiceIdFromUser, 
  updatedUser, 
  removedNewUser, 
  deletedUser
} from '@services/serviceOfUsers/helpers.js'
import { createStore } from 'vuex'
import {store as users} from "@/store/modules/users"
import axios from "axios"
import {defaultUsers} from "@mocks/users"

vi.mock('axios')

describe("tests services of users", () => {
  const store = createStore({
    plugins: [],
    modules: {
      users
    },
  })

  beforeEach(() => {
    store.dispatch('users/resetStore')
  })

  const adapterOfUsers = new AdapterOfUsers(import.meta.env.VITE_API_ADDR)
  const serviceOfUsers = new ServiceOfUsers(adapterOfUsers, store)

  axios.get.mockResolvedValue({
    data: defaultUsers,
  })

  test('Upload users by selected service', async () => {

    const uploadUsers = await serviceOfUsers.getUsersByService(1, 'dev')

    const expectedUsers = defaultUsers.filter(user => user.serviceId.includes(1))

    expect(expectedUsers).toEqual(uploadUsers) // users array selected service

  })

  test('Upload users without selected service', async () => {

    const uploadUsers = usersWithoutThisService(1, defaultUsers)

    const expectedUsers = defaultUsers.filter(user => !user.serviceId.includes(1))

    expect(expectedUsers).toEqual(uploadUsers) // users array without selected service

  })

  test('Added new user layout to user editor', async () => {
    const newUser = {id: -1, firstName: '',lastName: '', role: '', email: '', password: '', serviceId: []}

    const expectUser = await serviceOfUsers.addNewUser()

    expect({newUser: expectUser}).toEqual({newUser})
  })

  test('Added user to array users of selected service', async () => {

    const newUser = {
      "id": 6,
      "serviceId": [4, 5],
      "first_name": "Leanne 5",
      "last_name": "Graham",
      "email": "test@mail.ru",
      "role": "admin",
    }

    const updatedUsers = addedUser(newUser, defaultUsers)

    const addedNewUser = updatedUsers.find(user => user.id === 6)

    expect(addedNewUser).toEqual(newUser)
  })
  
  test('Get user by id from array users', async () => {

    const selectedIdUser = 3

    const selectedUser = getUserById(selectedIdUser, defaultUsers)

    expect(selectedUser.id).toEqual(selectedIdUser)
  })

  test('Filtered users of selected service', async () => {

    const selectedIdService = 3

    const usersWithSelectedService = usersWithThisService(selectedIdService, defaultUsers)

    expect(usersWithSelectedService).toHaveLength(3)

    usersWithSelectedService.map((user) => {
      return expect(user.serviceId.includes(selectedIdService)).toBe(true)
    })
  })

  test('Filtered users of not selected service', async () => {

    const selectedIdService = 3

    const usersWithSelectedService = usersWithoutThisService(selectedIdService, defaultUsers)

    expect(usersWithSelectedService).toHaveLength(2)

    usersWithSelectedService.map((user) => {
      return expect(!user.serviceId.includes(selectedIdService)).toBe(true)
    })
  })

  test('Added selected service to user with func addServiceIdToUser', async () => {

    const updatedUsers = addServiceIdToUser(4, 2, defaultUsers)

    const selectedUserWithoutService = defaultUsers.find(user => user.id === 4).serviceId.includes(2)
    const selectedUserWithService = updatedUsers.find(user => user.id === 4).serviceId.includes(2)

    expect(selectedUserWithoutService).toBe(false)
    expect(selectedUserWithService).toBe(true)
  })

  test('Deleted user from array users of selected service with func deleteServiceIdFromUser', async () => {

    const updatedUsers = deleteServiceIdFromUser(3, 2, defaultUsers)

    const selectedUserWithoutService = defaultUsers.find(user => user.id === 3).serviceId.includes(2)
    const selectedUserWithService = updatedUsers.find(user => user.id === 3).serviceId.includes(2)

    expect(selectedUserWithoutService).toBe(true)
    expect(selectedUserWithService).toBe(false)

  })

  test('Edited user updated in array users', async () => {
    
    const editerUser = 
    {
      "id": 3,
      "serviceId": [2, 3],
      "first_name": "Leanne 3 updated", // edited field
      "last_name": "Graham updated", // edited field
      "email": "test@mail.ru",
      "role": "admin",
    }

    const beforeEditUser = defaultUsers.find(user => user.id === 3)

    expect(beforeEditUser.first_name).not.toEqual('Leanne 3 updated') // check that user was not edited
    expect(beforeEditUser.last_name).not.toEqual('Graham updated') // check that user was not edited

    const updatedUsers = updatedUser(editerUser, defaultUsers)

    const getEditedUser = updatedUsers.find(user => user.id === 3)

    expect(getEditedUser.first_name).toEqual('Leanne 3 updated') // check that user was edited
    expect(getEditedUser.last_name).toEqual('Graham updated') // check that user was edited

  })

  test('Removed new user layout from array users', async () => {

    const newUser = {id: -1, first_name: '',last_name: '', role: '', email: '', password: '', serviceId: []}

    const updatedUsers = addedUser(newUser, defaultUsers)
    const beforeDeleteUser = updatedUsers.find(user => user.id === -1)

    expect(beforeDeleteUser).toBeDefined() // before delete user

    const afterDeleteUser = removedNewUser(updatedUsers)
    const deletedServiceStore = afterDeleteUser.find(service => service.id === -1)

    expect(deletedServiceStore).toBeUndefined() // after delete user

  })

  test('Updated users after deleting selected user with func deletedUser', async () => {
    
    const deleteUserId = 3
    
    const forDeleteUser = defaultUsers.find(user => user.id === 3)

    expect(forDeleteUser).toBeDefined() // before delete user

    const updatedUsers = deletedUser(deleteUserId, defaultUsers)

    const afterDeletingUser = updatedUsers.find(user => user.id === 3)

    expect(afterDeletingUser).toBeUndefined() // after delete user

  })

})