movied users from old project to new project anover repository, updated tests, cleared warns and errors in tests

users-manage/tests/views/3_organisms/Users/StaticMocks.js

@@ -0,0 +1,50 @@
+import {createStore} from "vuex";
+
+const users = {
+  namespaced: true,
+  state: {
+    usersOffSite: [],
+  },
+  mutations: {
+    setUsersOffSite(state, users) {
+      state.usersOffSite = users
+    }
+  },
+  getters: {
+    usersOffSite: state => {
+      return state.usersOffSite
+    }
+  },
+  actions: {
+    resetStore({state}) {
+      state.notIncludedSiteUsersList = []
+    },
+    saveUsersOffSite({commit}, users) {
+      console.log(users)
+      commit('setUsersOffSite', users)
+    }
+  },
+}
+
+const store = createStore({
+  plugins: [],
+  modules: {
+    users
+  },
+})
+
+class ServiceOfUsers {
+  constructor(adapter, store) {
+    this.adapter = adapter
+    this.store = store
+  }
+
+  async fetchUsersOffSite() {
+    const usersList = [{id: 1, name: 'user1'}, {id: 2, name: 'user2'}]
+    this.store.dispatch('users/saveUsersOffSite', usersList)
+  }
+}
+
+const serviceOfUsers = new ServiceOfUsers({}, store)
+
+export {store, serviceOfUsers}

users-manage/tests/views/3_organisms/Users/UsersManager.test.js

@@ -0,0 +1,163 @@
+import { mount} from '@vue/test-utils'
+import {createStore} from "vuex"
+import { expect, test, describe, vi, beforeEach } from 'vitest'
+import UsersManager from '@organisms/UsersManager/UsersManager.vue'
+import axios from "axios"
+import {store as services} from "@/store/modules/services"
+import {store as users} from "@/store/modules/users"
+import AdapterOfServices    from '@adapters/adapterOfServices/Services'
+import ServiceOfServices    from '@services/serviceOfServices/Services.js'
+import AdapterOfUsers    from '@adapters/adapterOfUsers/Users'
+import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
+import CaseOfUsersInService from '@useCases/CaseOfUsersInService.js'
+
+vi.mock('axios')
+
+describe("tests UsersManager component", () => {
+
+  const store = createStore({
+    plugins: [],
+    modules: {
+      services,
+      users
+    },
+  })
+
+  vi.mock('tabulator-tables', () => {
+    const mockTabulator = vi.fn().mockImplementation(() => ({
+      // Mock implementation details
+    }));
+    return { TabulatorFull: mockTabulator }; // Adjust based on what you're trying to mock
+  });
+
+  const adapterOfServices = new AdapterOfServices(import.meta.env.VITE_API_ADDR)
+  const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
+
+  const adapterOfUsers    = new AdapterOfUsers(import.meta.env.VITE_API_ADDR)
+  const serviceOfUsers =    new ServiceOfUsers(adapterOfUsers, store)
+  
+  const caseOfUsersInService = new CaseOfUsersInService(serviceOfUsers, serviceOfServices)
+
+  const mockData = [
+    {
+      "id": 1,
+      "serviceId": [1, 3],
+      "firstName": "Leanne 1",
+      "lastName": "Graham",
+      "email": "test@mail.ru",
+      "role": "admin",
+    },
+  ]
+  axios.get.mockResolvedValue({
+    data: mockData,
+  })
+
+  beforeEach(async () => {
+    store.dispatch('users/resetStore')
+  })
+
+
+  test('UsersManager mounted with vuex', async () => {
+    const wrapper = mount(UsersManager, {
+      global: {
+        plugins: [store],
+        props: {
+          serviceOfUsers
+        }
+      }
+    })
+
+    const userStatus = store.getters['users/userStatus']
+
+    expect(userStatus).toBe('inactive')
+    expect(wrapper.html()).toContain('w-full flex justify-between grow gap-4')
+    expect(wrapper.text()).toContain('Список пользователей')
+  })
+
+  test('View UserEditor component, after click to create user button', async () => {
+
+    await serviceOfUsers.getUsersByService(1, 'dev')
+
+    const wrapper = mount(UsersManager, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      }
+    })
+
+    const buttonCreate = wrapper.find('[test-id="toggle-new-user"]')
+    await buttonCreate.trigger('click')
+
+    const userStatus = store.getters['users/userStatus']
+    const wrapperHtml = wrapper.html()
+
+    expect(userStatus).toBe('create')
+    expect(wrapperHtml).toContain('Создать пользователя')
+    expect(wrapperHtml).toContain('Закрыть')
+    expect(wrapper.find('[test-id="new-user-container"]'))
+
+  })
+
+  test('View UserEditor component, after click to select user button', async () => {
+
+    await serviceOfUsers.getUsersByService(1, 'dev')
+    
+    const wrapper = mount(UsersManager, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers,
+        caseOfUsersInService,
+      },
+    })
+
+    const buttonSelect = wrapper.find('[test-id="toggle-add-user"]')
+    await buttonSelect.trigger('click')
+
+    const userStatus = store.getters['users/userStatus']
+    const wrapperHtml = wrapper.html()
+
+    expect(userStatus).toBe('select')
+    expect(wrapperHtml).toContain('Выбрать пользователя')
+    expect(wrapperHtml).toContain('Закрыть')
+    expect(wrapper.find('[action="add"]'))
+  })
+
+  test('Close UsersForSelection, after change userStatus', async () => {
+
+    await serviceOfUsers.getUsersByService(1, 'dev')
+
+    await serviceOfUsers.setStatusUser('select')
+
+    const wrapper = mount(UsersManager, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers,
+        caseOfUsersInService,
+      },
+    })
+
+    const userStatus = store.getters['users/userStatus']
+    const wrapperHtml = wrapper.html()
+
+    expect(userStatus).toBe('select')
+    expect(wrapperHtml).toContain('Выбрать пользователя')
+    expect(wrapperHtml).toContain('Закрыть')
+    expect(wrapper.find('[action="add"]'))
+
+    wrapper.vm.closeUserPanel()
+
+    const userStatusAfterClose = store.getters['users/userStatus']
+
+    expect(userStatusAfterClose).toBe('inactive')
+    
+  })
+  
+})
+
+

users-manage/tests/views/3_organisms/Users/UsersManagerContainer.test.js

@@ -0,0 +1,16 @@
+import {test, describe, expect} from 'vitest'
+import { mount} from '@vue/test-utils'
+import UsersManagerContainer from '@organisms/UsersManager/Container.vue';
+
+describe("tests UsersManagerContainer component", () => {
+  test('mount test of UsersManagerContainer', async () => {
+
+    const wrapper = mount(UsersManagerContainer, {
+      shallow: true,
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+})
+
+

users-manage/tests/views/3_organisms/Users/UsersManagerSelection.test.js

@@ -0,0 +1,181 @@
+import { expect, test, describe, vi, beforeEach } from 'vitest'
+import {createStore, mapGetters} from "vuex"
+import { mount} from '@vue/test-utils'
+import UsersSelection from '@organisms/UsersManager/UsersForSelection.vue'
+import VTabulator from '@molecules/Tabulator/VTabulator.vue'
+import axios from "axios"
+import {store as services} from "@/store/modules/services"
+import {store as users} from "@/store/modules/users"
+import AdapterOfServices    from '@adapters/adapterOfServices/Services'
+import ServiceOfServices    from '@services/serviceOfServices/Services.js'
+import AdapterOfUsers    from '@adapters/adapterOfUsers/Users'
+import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
+import CaseOfUsersInService from '@useCases/CaseOfUsersInService.js'
+
+vi.mock('axios')
+
+const defaultUsers = [
+  {
+    "id": 1,
+    "serviceId": [1, 3],
+    "firstName": "Leanne 1",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 2,
+    "serviceId": [1],
+    "firstName": "Leanne 2",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 3,
+    "serviceId": [2, 3],
+    "firstName": "Leanne 3",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 4,
+    "serviceId": [3],
+    "firstName": "Leanne 4",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 5,
+    "serviceId": [4, 5],
+    "firstName": "Leanne 5",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+]
+
+describe("tests UsersForSelection component", () => {
+
+  const store = createStore({
+    plugins: [],
+    modules: {
+      services,
+      users
+    },
+  })
+
+  beforeEach(async () => {
+    store.dispatch('users/resetStore')
+  })
+
+  vi.mock('tabulator-tables', () => {
+    const mockTabulator = vi.fn().mockImplementation(() => ({
+      // Mock implementation details
+    }))
+    return { TabulatorFull: mockTabulator }; // Adjust based on what you're trying to mock
+  })
+
+  axios.get.mockResolvedValue({
+    data: defaultUsers,
+  })
+
+  const adapterOfServices = new AdapterOfServices(import.meta.env.VITE_API_ADDR)
+  const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
+
+  const adapterOfUsers    = new AdapterOfUsers(import.meta.env.VITE_API_ADDR)
+  const serviceOfUsers =    new ServiceOfUsers(adapterOfUsers, store)
+  
+  const caseOfUsersInService = new CaseOfUsersInService(serviceOfUsers, serviceOfServices)
+
+  test('mount test of UsersManagerUsersTable', async () => {
+
+    const wrapper = mount(UsersSelection, {
+      global: {
+        plugins: [store],
+        props: {
+          caseOfUsersInService
+        }
+      }
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+
+  test('Added user to selected Service', async () => {
+
+    const selectedService = [
+      {
+        "id": 1,
+        "created_at": "2024-03-06T17:31:31.948355541+03:00",
+        "updated_at": "2024-03-06T17:31:31.948355541+03:00",
+        "deleted_at": null,
+        "name": "jsonplaceholder.typicode.com",
+        "port": 9965,
+        "proxy_ip": "172.25.78.153",
+        "device_ip": "https://jsonplaceholder.typicode.com/",
+        "internet_uri": "localhost",
+        "description": "localhost",
+        "is_online": true
+      },
+    ]
+
+    const addedUser = {
+      "id": 3,
+      "serviceId": [2, 3],
+      "firstName": "Leanne 3",
+      "lastName": "Graham",
+      "email": "test@mail.ru",
+      "role": "admin",
+    }
+
+    await serviceOfServices.fetchServices()
+    await serviceOfServices.selectService(selectedService[0])
+
+    await serviceOfUsers.getUsersByService(1, 'dev')
+    await serviceOfUsers.setSelectedUser(addedUser.id)
+
+    const wrapper = mount(UsersSelection, {
+      global: {
+        plugins: [store]
+      },
+      components: {VTabulator},
+      props: {
+        serviceOfUsers,
+        caseOfUsersInService,
+        users: defaultUsers,
+      },
+      computed: {
+        ...mapGetters('users', ['selectedUser', 'usersWithoutService']),
+      },
+    })
+
+    const usersWithServices = store.getters['users/usersWithService']
+
+    const forDeleteUserFromService = usersWithServices.find(user => user.id === addedUser.id)
+
+    expect(forDeleteUserFromService).toBeUndefined()
+
+    wrapper.vm.addUser(addedUser)
+
+    setTimeout(() => {
+
+      const usersWithServicesAfterDelete = store.getters['users/usersWithService']
+      const usersWithoutService = store.getters['users/usersWithoutService']
+
+      const userFromServiceAfterDelete = usersWithServicesAfterDelete.find(user => user.id === addedUser.id)
+      const userWithoutServiceAfterDelete = usersWithoutService.find(user => user.id === addedUser.id)
+
+      expect(userFromServiceAfterDelete).toBeDefined()
+      expect(userWithoutServiceAfterDelete).toBeUndefined()
+      expect(userWithoutServiceAfterDelete.id).toEqual(addedUser.id)
+
+    }, 100)
+
+  })
+
+})
+
+

users-manage/tests/views/3_organisms/Users/UsersManagerTable.test.js

@@ -0,0 +1,226 @@
+import { expect, test, describe, vi, beforeEach } from 'vitest'
+import {createStore, mapGetters} from "vuex"
+import { mount} from '@vue/test-utils'
+import UsersTable from '@organisms/UsersManager/UsersTable.vue'
+import VTabulator from '@molecules/Tabulator/VTabulator.vue'
+import axios from "axios"
+import {store as services} from "@/store/modules/services"
+import {store as users} from "@/store/modules/users"
+import AdapterOfServices    from '@adapters/adapterOfServices/Services'
+import ServiceOfServices    from '@services/serviceOfServices/Services.js'
+import AdapterOfUsers    from '@adapters/adapterOfUsers/Users'
+import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
+import CaseOfUsersInService from '@useCases/CaseOfUsersInService.js'
+
+vi.mock('axios')
+
+const defaultUsers = [
+  {
+    "id": 1,
+    "serviceId": [1, 3],
+    "firstName": "Leanne 1",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 2,
+    "serviceId": [1],
+    "firstName": "Leanne 2",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 3,
+    "serviceId": [2, 3],
+    "firstName": "Leanne 3",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 4,
+    "serviceId": [3],
+    "firstName": "Leanne 4",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 5,
+    "serviceId": [4, 5],
+    "firstName": "Leanne 5",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+]
+
+describe("tests UsersManagerUsersTable component", () => {
+
+  const store = createStore({
+    plugins: [],
+    modules: {
+      services,
+      users
+    },
+  })
+
+  beforeEach(async () => {
+    store.dispatch('users/resetStore')
+  })
+
+  vi.mock('tabulator-tables', () => {
+    const mockTabulator = vi.fn().mockImplementation(() => ({
+      // Mock implementation details
+    }))
+    return { TabulatorFull: mockTabulator }; // Adjust based on what you're trying to mock
+  })
+
+  axios.get.mockResolvedValue({
+    data: defaultUsers,
+  })
+
+  const adapterOfServices = new AdapterOfServices(import.meta.env.VITE_API_ADDR)
+  const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
+
+  const adapterOfUsers    = new AdapterOfUsers(import.meta.env.VITE_API_ADDR)
+  const serviceOfUsers =    new ServiceOfUsers(adapterOfUsers, store)
+  
+  const caseOfUsersInService = new CaseOfUsersInService(serviceOfUsers, serviceOfServices)
+
+  test('mount test of UsersManagerUsersTable', async () => {
+
+    const wrapper = mount(UsersTable, {
+      global: {
+        plugins: [store],
+        props: {
+          serviceOfUsers
+        }
+      }
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+
+  test('For Editing select current user in UserEditor', async () => {
+
+    const forEditUser = {
+      "id": 1,
+      "serviceId": [1, 3],
+      "firstName": "Leanne 1",
+      "lastName": "Graham",
+      "email": "test@mail.ru",
+      "role": "admin",
+    }
+
+    await serviceOfUsers.getUsers()
+
+    const wrapper = mount(UsersTable, {
+      global: {
+        plugins: [store]
+      },
+      components: {VTabulator},
+      props: {
+        serviceOfUsers
+      },
+      computed: {
+        ...mapGetters('users', ['userStatus']),
+      },
+    })
+
+    const selectedUser = store.getters['users/selectedUser']
+
+    expect(selectedUser).toBeNull()
+    expect(wrapper.vm.userStatus).toBe('inactive')
+
+    wrapper.vm.editUser(forEditUser)
+
+    const selectedUserAfterEdit = store.getters['users/selectedUser']
+    const userStatus = store.getters['users/userStatus']
+
+    expect(selectedUserAfterEdit).not.toBeNull()
+    expect(selectedUserAfterEdit.id).toEqual(forEditUser.id)
+    expect(userStatus).toBe('edit')
+  })
+
+  test('Delete user from selected Service', async () => {
+
+    const selectedService = [
+      {
+        "id": 1,
+        "created_at": "2024-03-06T17:31:31.948355541+03:00",
+        "updated_at": "2024-03-06T17:31:31.948355541+03:00",
+        "deleted_at": null,
+        "name": "jsonplaceholder.typicode.com",
+        "port": 9965,
+        "proxy_ip": "172.25.78.153",
+        "device_ip": "https://jsonplaceholder.typicode.com/",
+        "internet_uri": "localhost",
+        "description": "localhost",
+        "is_online": true
+      },
+    ]
+
+    const forDeleteUser = {
+      "id": 2,
+      "serviceId": [1],
+      "firstName": "Leanne 2",
+      "lastName": "Graham",
+      "email": "test@mail.ru",
+      "role": "admin",
+    }
+
+    await serviceOfServices.fetchServices()
+    await serviceOfServices.selectService(selectedService[0])
+
+    await serviceOfUsers.getUsersByService(1, 'dev')
+    await serviceOfUsers.setSelectedUser(forDeleteUser.id)
+
+    const wrapper = mount(UsersTable, {
+      global: {
+        plugins: [store]
+      },
+      components: {VTabulator},
+      props: {
+        serviceOfUsers,
+        caseOfUsersInService,
+        users: defaultUsers,
+      },
+      computed: {
+        ...mapGetters('users', ['selectedUser']),
+      },
+    })
+
+    const usersWithServices = store.getters['users/usersWithService']
+    const userStatus = store.getters['users/userStatus']
+
+    const forDeleteUserFromService = usersWithServices.find(user => user.id === forDeleteUser.id)
+
+    expect(forDeleteUserFromService).not.toBeNull()
+    expect(userStatus).toBe('inactive')
+
+    wrapper.vm.deleteUser(forDeleteUser)
+
+    setTimeout(() => {
+
+      const userStatusAfterDelete = store.getters['users/userStatus']
+      const usersWithServicesAfterDelete = store.getters['users/usersWithService']
+      const usersWithoutService = store.getters['users/usersWithoutService']
+
+      const userFromServiceAfterDelete = usersWithServicesAfterDelete.find(user => user.id === forDeleteUser.id)
+      const userWithoutServiceAfterDelete = usersWithoutService.find(user => user.id === forDeleteUser.id)
+
+      expect(userStatusAfterDelete).toBe('select')
+      expect(userFromServiceAfterDelete).toBeUndefined()
+      expect(userWithoutServiceAfterDelete).toBeDefined()
+      expect(userWithoutServiceAfterDelete.id).toEqual(forDeleteUser.id)
+
+    }, 100)
+
+  })
+
+})
+
+

users-manage/tests/views/3_organisms/Users/UsersManagerTitle.test.js

@@ -0,0 +1,16 @@
+import {test, describe, expect} from 'vitest'
+import { mount} from '@vue/test-utils'
+import UsersManagerTitle from '@organisms/UsersManager/Title.vue';
+
+describe("tests UsersManagerTitle component", () => {
+  test('mount test of UsersManagerTitle', async () => {
+
+    const wrapper = mount(UsersManagerTitle, {
+      shallow: true,
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+})
+
+

users-manage/tests/views/3_organisms/Users/UsersManagerUserEditor.test.js

@@ -0,0 +1,323 @@
+import { mount} from '@vue/test-utils'
+import { expect, test, describe, vi, beforeEach } from 'vitest'
+import UserEditor from '@organisms/UsersManager/UserEditor.vue';
+import { createStore, mapGetters } from 'vuex'
+import axios from "axios"
+import {store as users} from "@/store/modules/users"
+import {store as services} from "@/store/modules/services"
+import AdapterOfUsers    from '@adapters/adapterOfUsers/Users'
+import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
+
+vi.mock('axios')
+
+const defaultUsers = [
+  {
+    "id": 1,
+    "serviceId": [1, 3],
+    "firstName": "Leanne 1",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 2,
+    "serviceId": [1],
+    "firstName": "Leanne 2",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 3,
+    "serviceId": [2, 3],
+    "firstName": "Leanne 3",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 4,
+    "serviceId": [3],
+    "firstName": "Leanne 4",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+  {
+    "id": 5,
+    "serviceId": [4, 5],
+    "firstName": "Leanne 5",
+    "lastName": "Graham",
+    "email": "test@mail.ru",
+    "role": "admin",
+  },
+]
+
+describe("tests UserEditor component", () => {
+  const store = createStore({
+    plugins: [],
+    modules: {
+      services,
+      users
+    },
+  })
+
+  beforeEach( async () => {
+    store.dispatch('users/resetStore')
+
+  })
+
+  axios.get.mockResolvedValue({
+    data: defaultUsers,
+  })
+
+  const adapterOfUsers = new AdapterOfUsers(import.meta.env.VITE_API_ADDR)
+  const serviceOfUsers = new ServiceOfUsers(adapterOfUsers, store)
+
+  test('UserEditor mounted with vuex', async () => {
+    const wrapper = mount(UserEditor, {
+      shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      }
+    })
+
+    expect(wrapper.exists()).toBe(true)
+  })
+
+  test('Editing selected user in UserEditor', async () => {
+
+    store.dispatch('users/updateSelectedUser', defaultUsers[0])
+
+    const wrapper = mount(UserEditor, {
+      shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      },
+    })
+
+    const selectedUser = store.getters['users/selectedUser']
+
+    expect(selectedUser.firstName).toBe('Leanne 1')
+
+    wrapper.vm.editData({key: 'firstName', value: 'test Editing'})
+
+    const selectedUserAfterEdit = store.getters['users/selectedUser']
+
+    expect(selectedUserAfterEdit.firstName).toBe('test Editing')
+    
+  })
+
+  test('Saving after editing selected user in UserEditor', async () => {
+
+    const resServices = [
+      {
+        "id": 1,
+        "created_at": "2024-03-06T17:31:31.948355541+03:00",
+        "updated_at": "2024-03-06T17:31:31.948355541+03:00",
+        "deleted_at": null,
+        "name": "jsonplaceholder.typicode.com",
+        "port": 9965,
+        "proxy_ip": "172.25.78.153",
+        "device_ip": "https://jsonplaceholder.typicode.com/",
+        "internet_uri": "localhost",
+        "description": "localhost",
+        "is_online": true
+      },
+    ]
+
+    const editedUser = {
+      "id": 3,
+      "serviceId": [1, 3],
+      "firstName": "Leanne 3 edited",
+      "lastName": "Graham edited",
+      "email": "test@mail.ru",
+      "role": "admin",
+    }
+
+    await serviceOfUsers.getUsersByService(resServices[0].id, 'dev')
+
+    store.dispatch('services/editSelectedService', resServices)
+    store.dispatch('users/updateSelectedUser', editedUser)
+
+    const wrapper = mount(UserEditor, {
+      shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      },
+      computed: {
+        ...mapGetters('services', ["selectedService"]),
+        ...mapGetters('users', ['selectedUser']),
+      },
+    })
+
+    const selectedUser = store.getters['users/selectedUser']
+    wrapper.vm.saveUser()
+
+    const updatedUsersWithService = store.getters['users/usersWithService']
+    const userStatus = store.getters['users/userStatus']
+
+    const updatedUser = updatedUsersWithService.find(user => user.id === selectedUser.id)
+
+    expect(userStatus).toBe('inactive')
+    expect(updatedUser.firstName).toBe(editedUser.firstName)
+    expect(updatedUser.lastName).toBe(editedUser.lastName)
+
+  })
+  
+  test('Saving after creating new user in UserEditor', async () => {
+
+    const resServices = [
+      {
+        "id": 1,
+        "created_at": "2024-03-06T17:31:31.948355541+03:00",
+        "updated_at": "2024-03-06T17:31:31.948355541+03:00",
+        "deleted_at": null,
+        "name": "jsonplaceholder.typicode.com",
+        "port": 9965,
+        "proxy_ip": "172.25.78.153",
+        "device_ip": "https://jsonplaceholder.typicode.com/",
+        "internet_uri": "localhost",
+        "description": "localhost",
+        "is_online": true
+      },
+    ]
+
+    const newUser = {
+      "id": -1,
+      "serviceId": [],
+      "firstName": "Leanne 3 new",
+      "lastName": "Graham new",
+      "email": "test@mail.ru",
+      "role": "admin",
+    }
+
+    await serviceOfUsers.getUsersByService(resServices[0].id, 'dev')
+
+    store.dispatch('services/editSelectedService', resServices)
+    store.dispatch('users/updateSelectedUser', newUser)
+
+    const wrapper = mount(UserEditor, {
+      shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      },
+      computed: {
+        ...mapGetters('services', ["selectedService"]),
+        ...mapGetters('users', ['selectedUser']),
+      },
+    })
+
+    wrapper.vm.saveUser()
+
+    const updatedUsersWithService = store.getters['users/usersWithService']
+    const userStatus = store.getters['users/userStatus']
+
+    const updatedUser = updatedUsersWithService[0]
+
+    expect(userStatus).toBe('inactive')
+    expect(updatedUser.firstName).toBe(newUser.firstName)
+    expect(updatedUser.lastName).toBe(newUser.lastName)
+
+  })
+
+  test('Get Password for selected user in UserEditor', async () => {
+
+    const editedUser = {
+      "id": 3,
+      "serviceId": [1, 3],
+      "firstName": "Leanne 3 edited",
+      "lastName": "Graham edited",
+      "email": "test@mail.ru",
+      "role": "admin",
+    }
+
+    store.dispatch('users/updateSelectedUser', editedUser)
+
+    const wrapper = mount(UserEditor, {
+      shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      },
+    })
+
+    const selectedUser = store.getters['users/selectedUser']
+
+    expect(selectedUser).not.toHaveProperty('password')
+
+    wrapper.vm.getPassword()
+
+    const selectedUserAfterAddPass = store.getters['users/selectedUser']
+
+    expect(selectedUserAfterAddPass).toHaveProperty('password')
+  })
+
+  test('toggle view field Password for selected user in UserEditor', async () => {
+    const wrapper = mount(UserEditor, {
+      shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      },
+      data() {
+        return {
+          showNewPassword: false,
+          newPasswordType: 'password',
+        }
+      },
+    })
+
+    // await wrapper.setData({ showNewPassword: true })
+    // console.log('passwordField', passwordField.attributes().type)
+
+    wrapper.vm.togglePass()
+    
+    expect(wrapper.vm.showNewPassword).toBe(true)
+    expect(wrapper.vm.newPasswordType).toBe('text')
+
+  })
+
+  test('toggle view field RepeatPassword for selected user in UserEditor', async () => {
+    const wrapper = mount(UserEditor, {
+      shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfUsers
+      },
+      data() {
+        return {
+          showRepeatPassword: false,
+          repeatPasswordType: 'password',
+        }
+      },
+    })
+
+    wrapper.vm.toggleRepeatPass()
+    
+    expect(wrapper.vm.showRepeatPassword).toBe(true)
+    expect(wrapper.vm.repeatPasswordType).toBe('text')
+
+  })
+
+})
+
+