feat(tests): create useCase for UsersInServices

users-manage/tests/adapters/Users.test.js

@@ -1,11 +1,59 @@
-import {describe, expect, test} from "vitest";
+import {describe, expect, test, vi} from "vitest";
 import AdapterOfUsers from '@adapters/adapterOfUsers/Users'
+import axios from "axios";
+import {apiUser, appUser} from '@mocks/users.js'
 
+vi.mock('axios')
 
 describe('test for AdapterOfUsers', () => {
-  test('init', () => {
-    const adapterOfUsers = new AdapterOfUsers('http://localhost:8080')
+  const adapterOfUsers = new AdapterOfUsers('http://localhost:8080')
 
+  test('init', () => {
     expect(adapterOfUsers).toBeDefined()
   })
+
+  test('getUsersBySiteId', async () => {
+    axios.get.mockResolvedValue({
+      data: [apiUser],
+    })
+
+    const users = await adapterOfUsers.getUsersByServiceId(1)
+    expect(users).toEqual([appUser])
+  })
+
+  test('getUsers', async () => {
+    axios.get.mockResolvedValue({
+      data: [apiUser],
+    })
+
+    const users = await adapterOfUsers.getUsers()
+    expect(users).toEqual([appUser])
+  })
+
+  test('updateUser', async () => {
+    axios.put.mockResolvedValue({
+      data: apiUser,
+    })
+
+    const user = await adapterOfUsers.updateUser(appUser)
+    expect(user).toEqual(appUser)
+  })
+
+  test('createUser', async () => {
+    axios.post.mockResolvedValue({
+      data: apiUser,
+    })
+
+    const user = await adapterOfUsers.createUser()
+    expect(user).toEqual(appUser)
+  })
+
+  test('removeUser', async () => {
+    axios.delete.mockResolvedValue({
+      data: apiUser,
+    })
+
+    const user = await adapterOfUsers.removeUser(appUser.id)
+    expect(user).toEqual(appUser)
+  })
 })

users-manage/tests/mocks/adapters.js

@@ -0,0 +1,23 @@
+import {appUser} from "@mocks/users.js";
+
+class AdapterOfUsers {
+  constructor() {
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  async getUsersByServiceId() {
+    return [appUser]
+  }
+}
+
+class AdapterOfServices {
+  constructor() {
+  }
+}
+
+const adapterOfUsers    = new AdapterOfUsers()
+const adapterOfServices = new AdapterOfServices()
+
+export {
+  adapterOfUsers,
+  adapterOfServices}

users-manage/tests/mocks/users.js

@@ -0,0 +1,17 @@
+const apiUser = {
+  id: 1,
+  first_name: 'user1',
+  last_name: 'user1',
+  email: 'test@gmail.com',
+  role: 'user',
+}
+
+const appUser = {
+  id: 1,
+  firstName: 'user1',
+  lastName: 'user1',
+  email: 'test@gmail.com',
+  role: 'user',
+}
+
+export {apiUser, appUser}

users-manage/tests/services/serviceOfServices.test.js

@@ -59,6 +59,7 @@ describe('tests for ServiceOfServices', () => {
     const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
 
     await serviceOfServices.fetchServicesList()
+
     const usersList = store.getters['services/servicesList']
 
     expect(usersList).toEqual([{id: 1, name: 'service1'}, {id: 2, name: 'service2'}])

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

@@ -1,18 +0,0 @@
-import {describe, expect, test} from "vitest";
-import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
-
-class AdapterOfUsers {
-  constructor() {
-  }
-}
-
-describe('test for ServiceOfUsers', () => {
-  test('init', () => {
-    const adapterOfUsers = new AdapterOfUsers()
-
-    const serviceOfUsers = new ServiceOfUsers(adapterOfUsers)
-
-    expect(serviceOfUsers).toBeDefined()
-  })
-})
-

users-manage/tests/services/serviceOfUsers/MockData.js

@@ -0,0 +1,71 @@
+import {createStore} from "vuex";
+import {appUser} from "@mocks/users.js";
+
+class AdapterOfUsers {
+  constructor() {
+  }
+
+  getUsersList() {
+    return [appUser]
+  }
+
+  getUsersByServiceId() {
+    return [appUser]
+  }
+}
+
+const users = {
+  namespaced: true,
+  state: {
+    siteUsers: [],
+    usersWithoutSite: [],
+  },
+  mutations: {
+    setSiteUsers(state, users) {
+      state.siteUsers = users
+    },
+    setUsersWithoutSite(state, users) {
+      state.usersWithoutSite = users
+    },
+  },
+  getters: {
+    siteUsers: state => {
+      return state.siteUsers
+    },
+    usersWithoutSite: state => {
+      return state.usersWithoutSite
+    }
+  },
+  actions: {
+    resetStore({state}) {
+      state.siteUsers = []
+    },
+    saveSiteUsers({commit}, users) {
+      commit('setSiteUsers', users)
+    },
+    saveUsersWithoutSite({commit}, users) {
+      commit('setUsersWithoutSite', users)
+    }
+  },
+}
+
+
+const services = {
+  namespaced: true,
+  getters: {
+    selectedService: () => {
+      return {id: 1, name: 'service1'}
+    }
+  },
+}
+
+const store = createStore({
+  modules: {
+    users,
+    services
+  },
+})
+
+const adapterOfUsers = new AdapterOfUsers()
+
+export {adapterOfUsers, store}

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

@@ -0,0 +1,36 @@
+import {describe, expect, test, beforeEach} from "vitest";
+import ServiceOfUsers from '@services/serviceOfUsers/Users.js'
+import {adapterOfUsers, store} from './MockData.js'
+import {appUser} from '@mocks/users.js'
+
+describe('test for ServiceOfUsers', () => {
+  const serviceOfUsers = new ServiceOfUsers(adapterOfUsers, store)
+
+  beforeEach( async() => {
+    await store.dispatch('users/resetStore')
+  })
+
+  test('init', () => {
+    expect(serviceOfUsers).toBeDefined()
+  })
+
+  test('saveSiteUsers', async () => {
+    await serviceOfUsers.saveSiteUsers([appUser])
+    const storeUsers = store.getters['users/siteUsers']
+    expect(storeUsers).toEqual([appUser])
+  })
+
+  test('saveUsersWithoutSite', async () => {
+    await serviceOfUsers.saveUsersWithoutSite([appUser])
+    const storeUsers = store.getters['users/usersWithoutSite']
+    expect(storeUsers).toEqual([appUser])
+  })
+
+  test('fetchUsersByService', async () => {
+    const serviceId = 1
+    await serviceOfUsers.fetchUsersByService(serviceId)
+    const storeUsers = store.getters['users/siteUsers']
+    expect(storeUsers).toEqual([appUser])
+  })
+})
+

users-manage/tests/useCases/CaseOfUsersInService.test.js

@@ -1,106 +0,0 @@
-import {describe, expect, test, beforeEach} from "vitest";
-import CaseOfUsersInService from '@useCases/CaseOfUsersInService.js'
-import {createStore} from 'vuex'
-
-class ServiceOfUsers {
-  constructor(adapter, store) {
-    this.adapter = adapter
-    this.store = store
-  }
-}
-
-class ServiceOfServices {
-  constructor(adapter, store) {
-    this.adapter = adapter
-    this.store = store
-  }
-}
-
-class AdapterOfUsers {
-  constructor() {
-  }
-
-  // eslint-disable-next-line no-unused-vars
-  async getUsersListByServiceId(serviceId) {
-    return [{id: 1, name: 'user1'}, {id: 2, name: 'user2'}]
-  }
-}
-
-class AdapterOfServices {
-  constructor() {
-  }
-}
-
-describe('tests for caseOfUsersInService', () => {
-  const store = createStore({
-    modules: {
-      services: {
-        namespaced: true,
-        state: {
-          services: [],
-        },
-        mutations: {
-          setServices(state, services) {
-            state.services = services
-          },
-        },
-        actions: {
-          resetStore({state}) {
-            state.services = []
-          },
-          saveServices({commit}, services) {
-            commit('setServices', services)
-          }
-        },
-      },
-      users: {
-        namespaced: true,
-        state: {
-          siteUsersList: [],
-        },
-        mutations: {
-          setSiteUsersList(state, users) {
-            state.users = users
-          },
-        },
-        actions: {
-          resetStore({state}) {
-            state.siteUsersList = []
-          },
-          saveUsers({commit}, users) {
-            commit('setSiteUsersList', users)
-          }
-        },
-      },
-    },
-  })
-
-  const adapterOfUsers    = new AdapterOfUsers()
-  const adapterOfServices = new AdapterOfServices()
-
-  const serviceOfUsers    = new ServiceOfUsers(adapterOfUsers, store)
-  const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
-
-  beforeEach( async() => {
-    await store.dispatch('services/resetStore')
-    await store.dispatch('users/resetStore')
-  })
-
-  test('init', () => {
-    const caseOfUsersInService = new CaseOfUsersInService(serviceOfUsers, serviceOfServices)
-
-    expect(caseOfUsersInService).toBeDefined()
-  })
-
-  // test('selectServiceAndFetchRoutes', async () => {
-  //   const caseOfUsersInService = new CaseOfUsersInService(serviceOfUsers, serviceOfServices)
-  //
-  //   await caseOfUsersInService.selectServiceAndFetchRoutes(1)
-  //
-  //   const selectedService = store.getters['services/selectedService']
-  //   const usersList       = store.getters['users/siteUsersList']
-  //
-  //   expect(selectedService).toEqual({id: 1, name: 'service1'})
-  //   expect(usersList).toEqual([{id: 1, name: 'user1'}, {id: 2, name: 'user2'}])
-  // })
-})

users-manage/tests/useCases/CaseOfUsersInService/CaseOfUsersInService.test.js

@@ -0,0 +1,31 @@
+import {describe, expect, test, beforeEach} from "vitest";
+import CaseOfUsersInService from '@useCases/CaseOfUsersInService.js'
+import {serviceOfUsers, serviceOfServices, store} from './MockData.js'
+import {appUser} from '@mocks/users.js'
+
+
+describe('tests for caseOfUsersInService', () => {
+
+  beforeEach( async() => {
+    await store.dispatch('services/resetStore')
+    await store.dispatch('users/resetStore')
+  })
+
+  const caseOfUsersInService = new CaseOfUsersInService(serviceOfUsers, serviceOfServices)
+
+  test('init', () => {
+    expect(caseOfUsersInService).toBeDefined()
+  })
+
+  test('fetchUsersByService', async () => {
+    await caseOfUsersInService.fetchUsersByService()
+    const storeUsers = store.getters['users/siteUsers']
+    expect(storeUsers).toEqual([appUser])
+  })
+
+  // test('fetchUsersWithoutService', async () => {
+  //   await caseOfUsersInService.fetchUsersWithoutService()
+  //   const storeUsers = store.getters['users/usersWithoutSite']
+  //   expect(storeUsers).toEqual([appUser])
+  // })
+})

users-manage/tests/useCases/CaseOfUsersInService/MockData.js

@@ -0,0 +1,76 @@
+import {createStore} from "vuex";
+import {adapterOfUsers, adapterOfServices} from "@mocks/adapters.js";
+import ServiceOfUsers from "@services/serviceOfUsers/Users";
+import ServiceOfServices from "@services/serviceOfServices/Services";
+
+const services = {
+  namespaced: true,
+  state: {
+    services: [],
+  },
+  mutations: {
+    setServices(state, services) {
+      state.services = services
+    },
+  },
+  getters: {
+    selectedService: () => {
+      return {id: 1, name: 'service1'}
+    }
+  },
+  actions: {
+    resetStore({state}) {
+      state.services = []
+    },
+    saveServices({commit}, services) {
+      commit('setServices', services)
+    }
+  },
+}
+
+const users = {
+  namespaced: true,
+  state: {
+    siteUsers: [],
+    usersWithoutSite: [],
+  },
+  mutations: {
+    setSiteUsers(state, users) {
+      state.siteUsers = users
+    },
+    setUsersWithoutSite(state, users) {
+      state.usersWithoutSite = users
+    },
+  },
+  getters: {
+    siteUsers: state => {
+      return state.siteUsers
+    },
+    usersWithoutSite: state => {
+      return state.usersWithoutSite
+    }
+  },
+  actions: {
+    resetStore({state}) {
+      state.siteUsers = []
+    },
+    saveSiteUsers({commit}, users) {
+      commit('setSiteUsers', users)
+    },
+    saveUsersWithoutSite({commit}, users) {
+      commit('setUsersWithoutSite', users)
+    }
+  },
+}
+
+const store = createStore({
+  modules: {
+    services,
+    users,
+  },
+})
+
+const serviceOfUsers    = new ServiceOfUsers(adapterOfUsers, store)
+const serviceOfServices = new ServiceOfServices(adapterOfServices, store)
+
+export {serviceOfUsers, serviceOfServices, store}

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

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

users-manage/tests/views/2_molecules/TabulatorMock.js

@@ -1,4 +0,0 @@
-class Tabulator {
-}
-
-export default Tabulator;

users-manage/tests/views/3_organisms/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/UsersManager.test.js

@@ -1,21 +1,13 @@
 import { mount} from '@vue/test-utils'
 import { expect, test, describe, vi, beforeEach } from 'vitest'
 import UsersManager from '@organisms/UsersManager/UsersManager.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, serviceOfUsers} from './StaticMocks.js'
 
 vi.mock('axios')
 
+
 describe("tests SitesManagerPage component mounted with vuex", () => {
-  const store = createStore({
-    plugins: [],
-    modules: {
-      services,
-      users
-    },
-  })
 
   vi.mock('tabulator-tables', () => {
     const mockTabulator = vi.fn().mockImplementation(() => ({
@@ -26,7 +18,6 @@ describe("tests SitesManagerPage component mounted with vuex", () => {
 
   beforeEach(async () => {
     store.dispatch('users/resetStore')
-    store.dispatch('services/resetStore')
 
     const mockData = [
       {
@@ -55,12 +46,13 @@ describe("tests SitesManagerPage component mounted with vuex", () => {
   test('test UsersManager mounted with vuex', async () => {
     const wrapper = mount(UsersManager, {
       global: {
-        plugins: [store]
+        plugins: [store],
+        props: {
+          serviceOfUsers
+        }
       }
     })
 
-    console.log(wrapper.html())
-
     const componentState = wrapper.vm.componentState
     const gridCols = wrapper.vm.gridCols
     expect(componentState).toBe('view')
@@ -71,6 +63,9 @@ describe("tests SitesManagerPage component mounted with vuex", () => {
     const wrapper = mount(UsersManager, {
       global: {
         plugins: [store]
+      },
+      props: {
+        serviceOfUsers
       }
     })
 
@@ -82,7 +77,7 @@ describe("tests SitesManagerPage component mounted with vuex", () => {
     let wrapperHtml = wrapper.html()
     expect(componentState).toBe('create')
     expect(gridCols).toBe('grid-cols-2')
-    expect(wrapperHtml).toContain("Создать пользователя")
+    expect(wrapperHtml).toContain("new-user-container")
 
     await wrapper.vm.openUserPanelOfSelect()
     wrapperHtml = wrapper.html()
@@ -100,7 +95,7 @@ describe("tests SitesManagerPage component mounted with vuex", () => {
     expect(componentState).toBe('view')
     expect(gridCols).toBe('grid-cols-1')
     expect(wrapperHtml).not.toContain("Выбрать пользователя")
-    expect(wrapperHtml).not.toContain("Создать пользователя")
+    expect(wrapperHtml).not.toContain("new-user-container")
   })
 
   test('test UsersManager select user button', async () => {
@@ -108,14 +103,22 @@ describe("tests SitesManagerPage component mounted with vuex", () => {
       shallow: true,
       global: {
         plugins: [store]
+      },
+      props: {
+        serviceOfUsers
       }
     })
 
-    wrapper.vm.openUserPanelOfSelect()
+    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

@@ -11,6 +11,7 @@ describe("tests UsersManagerUsersTable component", () => {
 
     expect(wrapper.exists()).toBe(true)
   })
+
 })