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

users-manage/tests/views/2_molecules/Tabulator.test.js

@@ -1,6 +1,6 @@
 import {test, describe, expect, vi } from 'vitest'
 import { mount} from '@vue/test-utils'
-import VTabulator from '@molecules/VTabulator/VTabulator.vue';
+import VTabulator from '@molecules/Tabulator/VTabulator.vue';
 
 describe("tests VTabulator component", () => {
 

users-manage/tests/views/3_organisms/Services/EditServiceCard.test.js

@@ -0,0 +1,168 @@
+import { mount, config} from '@vue/test-utils'
+import { expect, test, describe, vi, beforeEach } from 'vitest'
+import EditServiceCard from "@organisms/ServicesList/EditServiceCard.vue"
+import { createStore } from 'vuex'
+import axios from "axios";
+import {store as services} from "@/store/modules/services"
+import AdapterOfServices    from '@adapters/adapterOfServices/Services'
+import ServiceOfServices    from '@services/serviceOfServices/Services.js'
+
+config.showDeprecationWarnings = false
+
+vi.mock('axios')
+
+
+describe("tests EditServiceCard component", () => {
+  const store = createStore({
+    plugins: [],
+    modules: {
+      services,
+    },
+  })
+
+  const defaultServices = [
+    {
+      "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",
+      "site_ip": "https://jsonplaceholder.typicode.com/",
+      "internet_uri": "localhost",
+      "description": "localhost",
+      "is_online": true
+    },
+  ]
+  
+  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
+    },
+  ]
+
+
+  axios.get.mockResolvedValue({
+    data: defaultServices,
+  })
+
+  beforeEach(async () => {
+    await store.dispatch('services/resetStore')
+  })
+
+  const adapterOfServices = new AdapterOfServices(import.meta.env.VITE_API_ADDR)
+  const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
+
+  test('EditServiceCard mounted with vuex', async () => {
+
+    store.commit('services/setSelectedService', resServices[0])
+    const selectedService = store.getters['services/selectedService']
+
+    const wrapper = mount(EditServiceCard, {
+      // shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        id: 1,
+      },
+    })
+
+    expect(selectedService).not.toBeNull()
+    expect(selectedService.id).toBe(1)
+    expect(wrapper.html()).toContain('flex justify-between items-center mb-2')
+    expect(wrapper.html()).toContain('Онлайн')
+    expect(wrapper.html()).toContain('Офлайн')
+    expect(wrapper.text()).toContain('Сохранить')
+  })
+
+  test("Cancel selected service in EditServiceCard", async () => {
+
+    config.showDeprecationWarnings = false
+
+    await serviceOfServices.fetchServices()
+
+    store.commit('services/setSelectedService', resServices[0])
+
+    const wrapper = mount(EditServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        id: 1,
+      },
+    })
+
+    wrapper.vm.cancelEditService()
+
+    const selectedService = store.getters['services/selectedService']
+    
+    expect(selectedService).toBeNull()
+  })
+
+  test("Editing selected service in EditServiceCard", async () => {
+
+    store.commit('services/setSelectedService', resServices[0])
+
+    const wrapper = mount(EditServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        id: 1,
+      },
+    })
+
+    const selectedService = store.getters['services/selectedService']
+
+    expect(selectedService.is_online).toEqual(true)
+
+    wrapper.vm.editData({key: 'is_online', value: false})
+
+    const selectedServiceAfterEditing = store.getters['services/selectedService']
+    
+    expect(selectedServiceAfterEditing.is_online).toEqual(false)
+  })
+
+  test("Set isSaveData for selected service in EditServiceCard", async () => {
+
+    store.commit('services/setSelectedService', resServices[0])
+
+    const wrapper = mount(EditServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        id: 1,
+      },
+    })
+
+    const isSaveData = store.getters['services/isSaveData']
+
+    expect(isSaveData).toEqual(false)
+
+    wrapper.vm.saveData()
+
+    const isSaveDataUpdated = store.getters['services/isSaveData']
+    
+    expect(isSaveDataUpdated).toEqual(true)
+  })
+
+})
+
+

users-manage/tests/views/3_organisms/Services/ServiceCard.test.js

@@ -0,0 +1,306 @@
+import { mount} from '@vue/test-utils'
+import { expect, test, describe, vi, beforeEach } from 'vitest'
+import ServiceCard from "@organisms/ServicesList/ServiceCard.vue"
+import { createStore} from 'vuex'
+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 Service Card component", () => {
+  const store = createStore({
+    plugins: [],
+    modules: {
+      services,
+      users
+    },
+  })
+
+  const defaultServices = [
+    {
+      "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",
+      "site_ip": "https://jsonplaceholder.typicode.com/",
+      "internet_uri": "localhost",
+      "description": "localhost",
+      "is_online": true
+    },
+  ]
+  
+  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
+    },
+  ]
+
+  axios.get.mockResolvedValue({
+    data: defaultServices,
+  })
+
+  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)
+
+  beforeEach(() => {
+    store.dispatch('services/resetStore')
+  })
+
+
+  test('Service Card mounted with vuex', async () => {
+    const wrapper = mount(ServiceCard, {
+      // shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        caseOfUsersInService,
+      },
+    })
+
+    // console.log('wrapper.html', wrapper.html())
+
+    await serviceOfServices.fetchServices()
+
+    store.commit('services/setServicesState', 'active')
+
+    const uploadServices = store.getters['services/services']
+    // const servicesState = store.getters['services/servicesState']
+
+    expect(uploadServices).toEqual(resServices) // full services array of store
+
+    expect(wrapper.html()).toContain('block w-full p-6 bg-white')
+    expect(wrapper.text()).toContain('статус')
+    expect(wrapper.text()).toContain('Порт')
+  })
+
+  test('View EditCard component after select service', async () => {
+
+    store.commit('services/setSelectedService', resServices[0])
+    const selectedService = store.getters['services/selectedService']
+
+    const wrapper = mount(ServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        caseOfUsersInService,
+        id: 1,
+      },
+    })
+
+    const wrapperHtml = wrapper.html()
+
+    expect(selectedService).not.toBeNull()
+    expect(selectedService.id).toBe(1)
+    expect(wrapperHtml).toContain('Сохранить')
+    expect(wrapper.find('textarea[name="description"]'))
+  })
+
+  test("Renders buttons - 'Отменить' and 'Удалить' in this service, after click to button delete service", async () => {
+
+    beforeEach(() => {
+      store.dispatch('services/resetStore')
+    })
+
+    const wrapper = mount(ServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        caseOfUsersInService,
+        id: 1,
+      },
+      data () {
+        return {
+          isDelete: false,
+        }
+      },
+    })
+
+    await wrapper.setData({ isDelete: true })
+
+    await wrapper.get('.ri-close-line').trigger('click')
+    
+    expect(wrapper.html()).toContain('Отменить')
+    expect(wrapper.html()).toContain('Удалить')
+  })
+
+  test("Cancel Renders buttons - 'Отменить' and 'Удалить' in this service, after click to button cancel delete service", async () => {
+
+    beforeEach(() => {
+      store.dispatch('services/resetStore')
+    })
+
+    const wrapper = mount(ServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        caseOfUsersInService,
+        id: 1,
+      },
+      data () {
+        return {
+          isDelete: true,
+        }
+      },
+    })
+
+    // console.log('wrapper.html', wrapper.html())
+
+    await wrapper.get('[test-id="canelButton"]').trigger('click')
+    
+    expect(wrapper.html()).not.toContain('Отменить')
+    expect(wrapper.html()).not.toContain('Удалить')
+  })
+
+  test('Set setStatus for prop isOnline in ServiceCard', async () => {
+    
+    const wrapper = mount(ServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        isOnline: false
+      },
+      data () {
+        return {
+          status: {title: 'disable', color: 'bg-red-700'}
+        }
+      },
+    })
+
+    // console.log('wrapper.html', wrapper.vm.status)
+
+    const defaultStatus = wrapper.vm.status
+
+    expect(defaultStatus.title).toContain('disable')
+    expect(defaultStatus.color).toContain('bg-red-700')
+
+    wrapper.vm.setStatus(true)
+
+    expect(wrapper.vm.status.title).toBe('enable')
+    expect(wrapper.html()).toContain('bg-green-700')
+
+  })
+
+  test('For Editing selected user in ServiceCard', async () => {
+
+    const forEditService = {
+      "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 wrapper = mount(ServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        caseOfUsersInService
+      },
+    })
+
+    const selectedService = store.getters['services/selectedService']
+
+    expect(selectedService).toBeNull()
+
+    await wrapper.vm.editService(forEditService)
+
+    const selectedUserAfterEdit = store.getters['services/selectedService']
+    const usersWithService = store.getters['users/usersWithService']
+
+    expect(selectedUserAfterEdit).not.toBeNull()
+    expect(selectedUserAfterEdit.id).toBe(1)
+
+    usersWithService.map(user => {
+      expect(user.serviceId.include(1)).toBe(true)
+    })
+    
+  })
+
+  test("View buttons - 'Отменить' and 'Удалить' after change isDelete for selected service in ServiceCard", async () => {
+
+    beforeEach(() => {
+      store.dispatch('services/resetStore')
+    })
+  
+    const wrapper = mount(ServiceCard, {
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        id: 1,
+      },
+      data () {
+        return {
+          isDelete: false,
+        }
+      },
+    })
+
+    // console.log('wrapper.html', wrapper.html())
+
+    const defaultIsDelete = wrapper.vm.isDelete
+
+    expect(defaultIsDelete).toBe(false)
+
+    await wrapper.get('.ri-close-line').trigger('click') // Рендер отрисовывает только с помощью триггером
+    // wrapper.vm.deleteService(true)
+
+    const updatedIsDelete = wrapper.vm.isDelete
+
+    // console.log('wrapper.html', wrapper.html())
+
+    expect(updatedIsDelete).toBe(true)
+
+    expect(wrapper.html()).toContain('Отменить')
+    expect(wrapper.html()).toContain('Удалить')
+
+  })
+
+})
+
+

users-manage/tests/views/3_organisms/Services/ServicesList.test.js

@@ -0,0 +1,154 @@
+import { mount} from '@vue/test-utils'
+import { expect, test, describe, vi } from 'vitest'
+import { toRefs } from 'vue'
+import ServicesList from "@organisms/ServicesList/ServicesList.vue"
+import { createStore } from 'vuex'
+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.js'
+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 Services List component", () => {
+  const store = createStore({
+    plugins: [],
+    modules: {
+      services,
+      users
+    },
+  })
+
+  const defaultServices = [
+    {
+      "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",
+      "site_ip": "https://jsonplaceholder.typicode.com/",
+      "internet_uri": "localhost",
+      "description": "localhost",
+      "is_online": true
+    },
+    {
+      "id": 2,
+      "created_at": "2024-03-07T11:43:51.026265459+03:00",
+      "updated_at": "2024-03-07T13:35:12.506368972+03:00",
+      "deleted_at": null,
+      "name": "new 2",
+      "port": 4548,
+      "proxy_ip": "172.25.78.151",
+      "site_ip": "172.25.78.151",
+      "internet_uri": "",
+      "description": "new site 2",
+      "is_online": true
+    },
+    {
+      "id": 3,
+      "created_at": "2024-03-07T11:43:51.027148541+03:00",
+      "updated_at": "2024-03-07T13:35:24.919273428+03:00",
+      "deleted_at": null,
+      "name": "new 3",
+      "port": 2527,
+      "proxy_ip": "172.25.78.151",
+      "site_ip": "172.25.78.151",
+      "internet_uri": "",
+      "description": "new site 3...",
+      "is_online": true
+    }
+  ]
+  
+  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
+    },
+    {
+      "id": 2,
+      "created_at": "2024-03-07T11:43:51.026265459+03:00",
+      "updated_at": "2024-03-07T13:35:12.506368972+03:00",
+      "deleted_at": null,
+      "name": "new 2",
+      "port": 4548,
+      "proxy_ip": "172.25.78.151",
+      "device_ip": "172.25.78.151",
+      "internet_uri": "",
+      "description": "new site 2",
+      "is_online": true
+    },
+    {
+      "id": 3,
+      "created_at": "2024-03-07T11:43:51.027148541+03:00",
+      "updated_at": "2024-03-07T13:35:24.919273428+03:00",
+      "deleted_at": null,
+      "name": "new 3",
+      "port": 2527,
+      "proxy_ip": "172.25.78.151",
+      "device_ip": "172.25.78.151",
+      "internet_uri": "",
+      "description": "new site 3...",
+      "is_online": true
+    }
+  ]
+
+  axios.get.mockResolvedValue({
+    data: defaultServices,
+  })
+
+  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('Services List mounted with vuex', async () => {
+    const wrapper = mount(ServicesList, {
+      // shallow: true,
+      global: {
+        plugins: [store]
+      },
+      props: {
+        serviceOfServices,
+        caseOfUsersInService,
+      },
+      setup (props) {
+        const {serviceOfServices} = toRefs(props)
+        serviceOfServices.value.fetchServices()
+      },
+    })
+
+    // console.log('wrapper.vm', wrapper.vm)
+
+    await serviceOfServices.fetchServices() 
+
+    const uploadServices = store.getters['services/services']
+
+    expect(uploadServices).toEqual(resServices) // full services array of store
+
+    expect(wrapper.html()).toContain('grid grid-cols-1')
+    expect(wrapper.text()).toContain('Добавить сайт')
+  })
+
+})
+
+

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

@@ -1,6 +1,6 @@
 import {test, describe, expect} from 'vitest'
 import { mount} from '@vue/test-utils'
-import UsersManagerContainer from '@organisms/UsersManager/UsersManagerContainer.vue';
+import UsersManagerContainer from '@organisms/UsersManager/Container.vue';
 
 describe("tests UsersManagerContainer component", () => {
   test('mount test of UsersManagerContainer', async () => {

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

@@ -1,6 +1,6 @@
 import {test, describe, expect} from 'vitest'
 import { mount} from '@vue/test-utils'
-import UsersManagerTitle from '@organisms/UsersManager/UsersManagerTitle.vue';
+import UsersManagerTitle from '@organisms/UsersManager/Title.vue';
 
 describe("tests UsersManagerTitle component", () => {
   test('mount test of UsersManagerTitle', async () => {

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')
+
+  })
+
+})
+
+

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

@@ -1,125 +0,0 @@
-import { mount} from '@vue/test-utils'
-import { expect, test, describe, vi, beforeEach } from 'vitest'
-import UsersManager from '@organisms/UsersManager/UsersManager.vue';
-import axios from "axios";
-import {store, serviceOfUsers} from './StaticMocks.js'
-
-vi.mock('axios')
-
-
-describe("tests SitesManagerPage component mounted with vuex", () => {
-
-  vi.mock('tabulator-tables', () => {
-    const mockTabulator = vi.fn().mockImplementation(() => ({
-      // Mock implementation details
-    }));
-    return { TabulatorFull: mockTabulator }; // Adjust based on what you're trying to mock
-  });
-
-  beforeEach(async () => {
-    store.dispatch('users/resetStore')
-
-    const mockData = [
-      {
-        "id": 1,
-        "created_at": "2024-02-22T17:08:37.715772388+03:00",
-        "updated_at": "2024-02-26T14:11:38.64094899+03:00",
-        "deleted_at": null,
-        "name": "jsonplaceholder.typicode.com",
-        "port": 9965,
-        "proxy_ip": "172.25.78.153",
-        "site_ip": "172.25.78.153",
-        "internet_uri": "localhost",
-        "description": "localhost",
-        "is_online": true
-      }
-    ]
-    axios.get.mockResolvedValue({
-      data: mockData,
-    })
-
-    await store.dispatch('services/uploadSites')
-
-    store.dispatch('services/uploadAndSelectService', 1)
-  })
-
-  test('test UsersManager mounted with vuex', async () => {
-    const wrapper = mount(UsersManager, {
-      global: {
-        plugins: [store],
-        props: {
-          serviceOfUsers
-        }
-      }
-    })
-
-    const componentState = wrapper.vm.componentState
-    const gridCols = wrapper.vm.gridCols
-    expect(componentState).toBe('view')
-    expect(gridCols).toBe('grid-cols-1')
-  })
-
-  test('test UsersManager create user button', async () => {
-    const wrapper = mount(UsersManager, {
-      global: {
-        plugins: [store]
-      },
-      props: {
-        serviceOfUsers
-      }
-    })
-
-    await wrapper.vm.openUserPanelOfCreate()
-
-    let componentState = wrapper.vm.componentState
-    let gridCols = wrapper.vm.gridCols
-
-    let wrapperHtml = wrapper.html()
-    expect(componentState).toBe('create')
-    expect(gridCols).toBe('grid-cols-2')
-    expect(wrapperHtml).toContain("new-user-container")
-
-    await wrapper.vm.openUserPanelOfSelect()
-    wrapperHtml = wrapper.html()
-    componentState = wrapper.vm.componentState
-    gridCols = wrapper.vm.gridCols
-    expect(componentState).toBe('select')
-    expect(gridCols).toBe('grid-cols-2')
-    expect(wrapperHtml).toContain("Выбрать пользователя")
-    expect(wrapperHtml).toContain("Выбрать пользователя")
-
-    await wrapper.vm.closeUserPanel()
-    wrapperHtml = wrapper.html()
-    componentState = wrapper.vm.componentState
-    gridCols = wrapper.vm.gridCols
-    expect(componentState).toBe('view')
-    expect(gridCols).toBe('grid-cols-1')
-    expect(wrapperHtml).not.toContain("Выбрать пользователя")
-    expect(wrapperHtml).not.toContain("new-user-container")
-  })
-
-  test('test UsersManager select user button', async () => {
-    const wrapper = mount(UsersManager, {
-      shallow: true,
-      global: {
-        plugins: [store]
-      },
-      props: {
-        serviceOfUsers
-      }
-    })
-
-    await wrapper.vm.openUserPanelOfSelect()
-
-    const usersOffSite = store.getters['users/usersOffSite']
-
-    const componentState = wrapper.vm.componentState
-    const gridCols = wrapper.vm.gridCols
-
-    expect(componentState).toBe('select')
-    expect(gridCols).toBe('grid-cols-2')
-    expect(usersOffSite).toEqual([{id: 1, name: 'user1'}, {id: 2, name: 'user2'}])
-  })
-})
-
-

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

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

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

@@ -1,56 +0,0 @@
-import { mount} from '@vue/test-utils'
-import { expect, test, describe, vi, beforeEach } from 'vitest'
-import UsersManagerUserEditor from '@organisms/UsersManager/UsersManagerUserEditor.vue';
-import { createStore } from 'vuex'
-import {store as users} from '@/store/modules/users';
-import axios from "axios";
-
-vi.mock('axios')
-
-describe("tests UsersManagerUserEditor component mounted with vuex", () => {
-  const store = createStore({
-    plugins: [],
-    modules: {
-      users
-    },
-  })
-
-  beforeEach( async () => {
-    store.dispatch('users/resetStore')
-
-    const mockData = [
-      {
-        "id": 1,
-        "created_at": "2024-02-22T17:08:37.715772388+03:00",
-        "updated_at": "2024-02-26T14:11:38.64094899+03:00",
-        "deleted_at": null,
-        "name": "jsonplaceholder.typicode.com",
-        "port": 9965,
-        "proxy_ip": "172.25.78.153",
-        "site_ip": "172.25.78.153",
-        "internet_uri": "localhost",
-        "description": "localhost",
-        "is_online": true
-      }
-    ]
-    axios.get.mockResolvedValue({
-      data: mockData,
-    })
-    await store.dispatch('services/uploadSites')
-
-    store.dispatch('services/uploadAndSelectService', 1)
-  })
-
-  test('tests UsersManager mounted with vuex', async () => {
-    const wrapper = mount(UsersManagerUserEditor, {
-      shallow: true,
-      global: {
-        plugins: [store]
-      }
-    })
-
-    expect(wrapper.exists()).toBe(true)
-  })
-})
-
-

users-manage/tests/views/5_pages/SitesList.test.js

@@ -1,15 +1,17 @@
 import { mount} from '@vue/test-utils'
 import { expect, test, describe, vi } from 'vitest'
-import Sites from '@pages/SitesManagerPage/SitesManagerPage.vue';
+import Services from '@pages/ServicesManagerPage/ServicesManagerPage.vue';
 import { createStore } from 'vuex'
-import {store as services} from '@/store/modules/services';
-import {store as users} from '@/store/modules/users';
 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'
 
 vi.mock('axios')
 
 
-describe("tests App mounted with vuex", () => {
+describe("tests Services Manager Page component", () => {
   const store = createStore({
     plugins: [],
     modules: {
@@ -18,48 +20,64 @@ describe("tests App mounted with vuex", () => {
     },
   })
 
-  const mockData = [
+  const defaultServices = [
     {
       "id": 1,
-      "first_name": "Leanne",
-      "last_name": "Graham",
-      "email": "test@mail.ru",
-      "role": "admin",
-      "is_active": true
-    }
+      "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",
+      "site_ip": "https://jsonplaceholder.typicode.com/",
+      "internet_uri": "localhost",
+      "description": "localhost",
+      "is_online": true
+    },
+  ]
+
+  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
+    },
   ]
 
   axios.get.mockResolvedValue({
-    data: mockData,
+    data: defaultServices,
   })
 
-  test('tests App mounted with vuex', async () => {
-    const wrapper = mount(Sites, {
-      shallow: true,
+  const adapterOfServices = new AdapterOfServices(import.meta.env.VITE_API_ADDR)
+  const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
+
+  test('Services Manager Page mounted with vuex', async () => {
+    const wrapper = mount(Services, {
+      // shallow: true,
       global: {
         plugins: [store]
       }
     })
 
-    const siteId = 1
-    const answer = await wrapper.vm.selectSite(siteId, "production")
+    // console.log('wrapper.vm', wrapper.vm)
 
-    const usersList = store.getters['users/usersList']
-    const componentState = store.getters['users/componentState']
-    const selectedService = store.getters['services/selectedService']
+    await serviceOfServices.fetchServices()
 
-    expect(usersList).toEqual([{
-      "id": 1,
-      "first_name": "Leanne",
-      "last_name": "Graham",
-      "email": "test@mail.ru",
-      "role": "admin",
-      "is_active": true
-    }])
-    expect(componentState).toEqual('active')
-    expect(selectedService).toBe(null)
-    expect(answer).toBe("ok")
+    const uploadServices = store.getters['services/services']
+
+    expect(uploadServices).toEqual(resServices) // full services array of store
+    expect(wrapper.html()).toContain('me-2 mb-6')
+    expect(wrapper.text()).toContain('На главную')
   })
+
 })