test/views/settings/index.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import Vuex from 'vuex'
+import { mount, createLocalVue, config } from '@vue/test-utils'
+import Element from 'element-ui'
+import Settings from '@/views/settings/index'
+import flushPromises from 'flush-promises'
+import app from '@/store/modules/app'
+import settings from '@/store/modules/settings'
+import user from '@/store/modules/user'
+import getters from '@/store/getters'
+import _ from 'lodash'
+
+config.mocks["$t"] = () => {}
+
+const localVue = createLocalVue()
+localVue.use(Vuex)
+localVue.use(Element)
+
+jest.mock('@/api/app')
+jest.mock('@/api/nodeInfo')
+jest.mock('@/api/settings')
+
+describe('Settings search', () => {
+  let store
+  let actions
+  let appActions
+  let $route
+  let $router
+
+  beforeEach(() => {
+    appActions = { ...app.actions, NeedReboot: jest.fn() }
+    actions = { ...settings.actions, FetchSettings: jest.fn(), GetNodeInfo: jest.fn() }
+    store = new Vuex.Store({
+      modules: {
+        app: { ...app, actions: appActions },
+        settings: { ...settings, actions },
+        user: { ...user, state: { ...user.state, authHost: 'localhost:4000' }}
+      },
+      getters
+    })
+    $route = { path: '/settings/path' }
+    $router = { push: jest.fn(), currentRoute: {} }
+  })
+
+  it('shows search input', async (done) => {
+    const wrapper = mount(Settings, {
+      store,
+      mocks: {
+        $route,
+        $router
+      },
+      localVue
+    })
+
+    await flushPromises()
+    const searchInput = wrapper.find('.settings-search-input')
+    expect(searchInput.exists()).toBe(true)
+    done()
+  })
+
+  it('changes tab when search value was selected', async (done) => {
+    const wrapper = mount(Settings, {
+      store,
+      mocks: {
+        $route,
+        $router
+      },
+      localVue
+    })
+    wrapper.vm.handleSearchSelect({ group: 'Pleroma.Upload', key: 'Pleroma.Upload' })
+    expect(store.state.settings.searchQuery).toBe('Pleroma.Upload')
+    expect($router.push).toHaveBeenCalledWith({ path: '/settings/upload' })
+
+    wrapper.vm.handleSearchSelect({ group: ':swoosh', key: ':serve_mailbox' })
+    expect(store.state.settings.searchQuery).toBe(':serve_mailbox')
+    expect($router.push).toHaveBeenCalledWith({ path: '/settings/mailer' })
+
+    wrapper.vm.handleSearchSelect({ group: ':pleroma', key: ':admin_token' })
+    expect(store.state.settings.searchQuery).toBe(':admin_token')
+    expect($router.push).toHaveBeenCalledWith({ path: '/settings/instance' })
+
+    wrapper.vm.handleSearchSelect({ group: ':media_proxy', key: ':ssl_options' })
+    expect(store.state.settings.searchQuery).toBe(':ssl_options')
+    expect($router.push).toHaveBeenCalledWith({ path: '/settings/media-proxy' })
+
+    done()
+  })
+})

test/views/settings/settingFollowsRules.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { settingFollowsRules } from '@/views/settings/rules'
+
+describe('Check if settings follow rules', () => {
+  it('does not render :proxy_remote when local :uploader is selected', () => {
+    const state = { ':pleroma': { 'Pleroma.Upload': { ':uploader': 'Pleroma.Uploaders.Local' }}}
+
+    expect(settingFollowsRules(':proxy_remote', 'Pleroma.Upload', state)).toBeFalsy()
+  })
+
+  it('render :proxy_remote when local :uploader is not selected', () => {
+    const state = { ':pleroma': { 'Pleroma.Upload': { ':uploader': 'Pleroma.Uploaders.S3' }}}
+
+    expect(settingFollowsRules(':proxy_remote', 'Pleroma.Upload', state)).toBeTruthy()
+  })
+
+  it('render setting when there is no rule', () => {
+    const state = { ':pleroma': { 'Pleroma.Upload': { ':uploader': 'Pleroma.Uploaders.Local' }}}
+
+    expect(settingFollowsRules(':filters', 'Pleroma.Upload', state)).toBeTruthy()
+  })
+
+  it('render setting when one of the keys is undefined', () => {
+    const state = { ':pleroma': {}}
+
+    expect(settingFollowsRules(':level', undefined, state)).toBeTruthy()
+
+    expect(settingFollowsRules(':admin_token', undefined, state)).toBeTruthy()
+  })
+
+  it('render setting when state is empty', () => {
+    const state = { ':pleroma': { 'Pleroma.Upload': {}}}
+
+    expect(settingFollowsRules(':proxy_remote', 'Pleroma.Upload', state)).toBeTruthy()
+  })
+})
\ No newline at end of file

test/views/statuses/index.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import Vuex from 'vuex'
+import { mount, createLocalVue, config } from '@vue/test-utils'
+import flushPromises from 'flush-promises'
+import Element from 'element-ui'
+import Statuses from '@/views/statuses/index'
+import storeConfig from './store.conf'
+import { cloneDeep } from 'lodash'
+
+config.mocks["$t"] = () => {}
+config.stubs.transition = false
+
+const localVue = createLocalVue()
+localVue.use(Vuex)
+localVue.use(Element)
+
+jest.mock('@/api/app')
+jest.mock('@/api/nodeInfo')
+jest.mock('@/api/peers')
+jest.mock('@/api/settings')
+jest.mock('@/api/status')
+
+describe('Statuses', () => {
+  let store
+
+  beforeEach(() => {
+    store = new Vuex.Store(cloneDeep(storeConfig))
+  })
+
+  it('fetches peers and statuses count', async (done) => {
+    mount(Statuses, {
+      store,
+      localVue
+    })
+
+    await flushPromises()
+    const statusVisibilityCount = store.state.status.statusVisibility
+    expect(statusVisibilityCount.direct).toEqual(4)
+    expect(statusVisibilityCount.private).toEqual(10)
+    expect(statusVisibilityCount.public).toEqual(4)
+    expect(statusVisibilityCount.unlisted).toEqual(10)
+    done()
+  })
+
+  it('fetches statuses from selected instance and updates the count', async (done) => {
+    const wrapper = mount(Statuses, {
+      store,
+      localVue
+    })
+    await flushPromises()
+
+    store.dispatch('HandleFilterChange', 'heaven.com')
+    wrapper.vm.handleFilterChange()
+    await flushPromises()
+    const statusVisibilityCount = store.state.status.statusVisibility
+
+    expect(statusVisibilityCount.direct).toEqual(1)
+    expect(statusVisibilityCount.private).toEqual(2)
+    expect(statusVisibilityCount.public).toEqual(3)
+    expect(statusVisibilityCount.unlisted).toEqual(0)
+    expect(store.state.status.fetchedStatuses.length).toEqual(2)
+    done()
+  })
+
+  it('handles status select', async (done) => {
+    const wrapper = mount(Statuses, {
+      store: store,
+      localVue
+    })
+    await flushPromises()
+
+    store.dispatch('HandleFilterChange', 'heaven.com')
+    wrapper.vm.handleFilterChange()
+    await flushPromises()
+    wrapper.find('.status-checkbox input').setChecked()
+    await flushPromises()
+
+    expect(wrapper.vm.selectedUsers.length).toEqual(1)
+    expect(wrapper.vm.selectedUsers[0].nickname).toBe('sky')
+    done()
+  })
+
+  it('clear state after component was destroyed', async (done) => {
+    const wrapper = mount(Statuses, {
+      store: store,
+      localVue
+    })
+    await flushPromises()
+
+    store.dispatch('HandleFilterChange', 'heaven.com')
+    wrapper.vm.handleFilterChange()
+    await flushPromises()
+    wrapper.find('.status-checkbox input').setChecked()
+    await flushPromises()
+
+    expect(wrapper.vm.selectedUsers.length).toEqual(1)
+    expect(store.state.status.statusesByInstance.selectedInstance).toBe('heaven.com')
+    expect(store.state.status.fetchedStatuses.length).toEqual(2)
+    wrapper.destroy()
+
+    expect(wrapper.vm.selectedUsers.length).toEqual(0)
+    expect(store.state.status.statusesByInstance.selectedInstance).toBe('')
+    expect(store.state.status.fetchedStatuses.length).toEqual(0)
+    done()
+  })
+})

test/views/statuses/pagination.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import Vuex from 'vuex'
+import { mount, createLocalVue, config } from '@vue/test-utils'
+import flushPromises from 'flush-promises'
+import Element from 'element-ui'
+import Statuses from '@/views/statuses/index'
+import storeConfig from './storeForPagination.conf'
+import { cloneDeep } from 'lodash'
+
+config.mocks["$t"] = () => {}
+config.stubs.transition = false
+
+const localVue = createLocalVue()
+localVue.use(Vuex)
+localVue.use(Element)
+
+jest.mock('@/api/app')
+jest.mock('@/api/nodeInfo')
+jest.mock('@/api/peers')
+jest.mock('@/api/settings')
+jest.mock('@/api/status')
+
+describe('Statuses', () => {
+  let store
+
+  beforeEach(() => {
+    store = new Vuex.Store(cloneDeep(storeConfig))
+  })
+
+  it('pagination', async (done) => {
+    const wrapper = mount(Statuses, {
+      store,
+      localVue
+    })
+    await flushPromises()
+
+    store.dispatch('HandleFilterChange', 'heaven.com')
+    wrapper.vm.handleFilterChange()
+    await flushPromises()
+
+    expect(store.state.status.statusesByInstance.allLoaded).toBe(false)
+    expect(store.state.status.statusesByInstance.page).toBe(1)
+    wrapper.find('.statuses-pagination button').trigger('click')
+    await flushPromises()
+
+    expect(store.state.status.statusesByInstance.allLoaded).toBe(false)
+    expect(store.state.status.statusesByInstance.page).toBe(2)
+
+    wrapper.find('.statuses-pagination button').trigger('click')
+    await flushPromises()
+
+    expect(store.state.status.statusesByInstance.allLoaded).toBe(true)
+
+    done()
+  })
+})

test/views/statuses/show.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import Vuex from 'vuex'
+import { mount, createLocalVue, config, RouterLinkStub } from '@vue/test-utils'
+import flushPromises from 'flush-promises'
+import Element from 'element-ui'
+import StatusShow from '@/views/statuses/show'
+import storeConfig from './statusShowStore.conf'
+import { cloneDeep } from 'lodash'
+
+config.mocks["$t"] = () => {}
+config.stubs.transition = false
+
+const localVue = createLocalVue()
+localVue.use(Vuex)
+localVue.use(Element)
+
+const $route = {
+  params: {
+    id: '9vJOO3iFPyjNaEhJ5s'
+  }
+}
+
+jest.mock('@/api/app')
+jest.mock('@/api/nodeInfo')
+jest.mock('@/api/peers')
+jest.mock('@/api/settings')
+jest.mock('@/api/status')
+jest.mock('@/api/users')
+
+describe('Status show page', () => {
+  let store
+
+  beforeEach(() => {
+    store = new Vuex.Store(cloneDeep(storeConfig))
+  })
+
+  it(`fetches single status and user's statuses`, async (done) => {
+    const wrapper = mount(StatusShow, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      },
+      mocks: {
+        $route
+      }
+    })
+    await flushPromises()
+
+    expect(wrapper.find('.status-container').isVisible()).toBe(true)
+    expect(store.state.status.fetchedStatus.id).toBe('9vJOO3iFPyjNaEhJ5s')
+    expect(store.state.status.fetchedStatus.account.nickname).toBe('dolin')
+    expect(store.state.userProfile.statuses.length).toEqual(3)
+    done()
+  })
+
+  it(`renders links and user's moderation menu`, async (done) => {
+    const wrapper = mount(StatusShow, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      },
+      mocks: {
+        $route
+      }
+    })
+    await flushPromises()
+
+    expect(wrapper.findComponent(RouterLinkStub).find('h1').text()).toBe('dolin')
+    expect(wrapper.find('button.moderate-user-button').exists()).toBe(true)
+    expect(wrapper.find('.el-dropdown-menu').exists()).toBe(true)
+    done()
+  })
+
+  it(`renders status card`, async (done) => {
+    const wrapper = mount(StatusShow, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      },
+      mocks: {
+        $route
+      }
+    })
+    await flushPromises()
+
+    expect(wrapper.find('.status-card').exists()).toBe(true)
+    expect(wrapper.findAllComponents(RouterLinkStub).at(1).find('span.status-account-name').text()).toBe('dolin')
+    expect(wrapper.find('span.el-tag').text()).not.toBe('Sensitive')
+    expect(wrapper.find('span.el-tag').text()).toBe('Public')
+    expect(wrapper.find('button.status-actions-button').exists()).toBe(true)
+    expect(wrapper.find('.status-body .status-content').text()).toBe('pizza makes everything better')
+    done()
+  })
+})

test/views/statuses/statusShowStore.conf.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import app from '@/store/modules/app'
+import peers from '@/store/modules/peers'
+import user from '@/store/modules/user'
+import userProfile from '@/store/modules/userProfile'
+import users from '@/store/modules/users'
+import settings from '@/store/modules/settings'
+import status from '@/store/modules/status'
+import getters from '@/store/getters'
+
+export default {
+  modules: {
+    app,
+    peers,
+    settings,
+    status,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: ['admin'],
+        privileges: [
+          'users_manage_activation_state',
+          'users_delete',
+          'users_manage_tags',
+          'users_manage_credentials',
+          'messages_delete'
+        ]
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}

test/views/statuses/store.conf.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import app from '@/store/modules/app'
+import peers from '@/store/modules/peers'
+import user from '@/store/modules/user'
+import users from '@/store/modules/users'
+import settings from '@/store/modules/settings'
+import status from '@/store/modules/status'
+import getters from '@/store/getters'
+
+export default {
+  modules: {
+    app,
+    peers,
+    settings,
+    status,
+    user: { ...user, state: { ...user.state, authHost: 'localhost:4000' }},
+    users
+  },
+  getters
+}

test/views/statuses/storeForPagination.conf.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import app from '@/store/modules/app'
+import peers from '@/store/modules/peers'
+import user from '@/store/modules/user'
+import settings from '@/store/modules/settings'
+import status from '@/store/modules/status'
+import getters from '@/store/getters'
+
+export default {
+  modules: {
+    app,
+    peers,
+    settings,
+    status: { ...status, state: { ...status.state, statusesByInstance: { ...status.state.statusesByInstance, pageSize: 1 }}},
+    user: { ...user, state: { ...user.state, authHost: 'localhost:4000' }}
+  },
+  getters
+}

test/views/users/components/ModerationDropdown.test.js

+import Vuex from 'vuex'
+import { mount, createLocalVue, config, RouterLinkStub } from '@vue/test-utils'
+import flushPromises from 'flush-promises'
+import Element from 'element-ui'
+import Users from '@/views/users/index'
+import {
+  storeNoPrivilegesNoRoles,
+  storeWithTagPolicyNoPrivilegesRolesAdmin,
+  storeWithPrivilegesUsersManageActivationStateNoRoles,
+  storeWithPrivilegesUsersDeleteNoRoles,
+  storeWithTagPolicyPrivilegesUsersManageTagsNoRoles,
+  storeWithTagPolicyPrivilegesUsersManageTagsRolesAdmin,
+  storeWithPrivilegesUsersManageCredentialsNoRoles
+} from './store.conf'
+import { cloneDeep } from 'lodash'
+
+config.mocks["$t"] = (key) => key
+
+const localVue = createLocalVue()
+localVue.use(Vuex)
+localVue.use(Element)
+
+jest.mock('@/api/app')
+jest.mock('@/api/nodeInfo')
+jest.mock('@/api/users')
+jest.mock('@/api/settings')
+
+describe('The Multiple Users Moderation Menu', () => {
+  it('doesnt show for someone with no privileges and no roles', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeNoPrivilegesNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+
+    expect(wrapper.find('.moderation-dropdown-menu').exists()).toEqual(false)
+    done()
+  })
+
+  it('shows for someone with admin role and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithTagPolicyNoPrivilegesRolesAdmin))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    const menu = wrapper.findAll('.moderation-dropdown-menu').at(0)
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual([
+      'users.bot users.person',
+      'users.disableMfa',
+      'users.grantModerator',
+      'users.requirePasswordReset',
+      'users.revokeAdmin',
+    ])
+
+    store.state.users.mrfPolicies = []
+    await flushPromises()
+
+    expect(menu_items.length).toEqual(menu_items_text.length)
+    done()
+  })
+
+  it('shows for someone with users_manage_activation_state privilege and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithPrivilegesUsersManageActivationStateNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    const menu = wrapper.findAll('.moderation-dropdown-menu').at(0)
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual(['users.deactivateAccount'])
+
+    done()
+  })
+
+  it('shows for someone with users_delete privilege and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithPrivilegesUsersDeleteNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    const menu = wrapper.findAll('.moderation-dropdown-menu').at(0)
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual(['users.deleteAccount'])
+
+    done()
+  })
+
+  it('shows for someone with users_manage_tags privilege and shows proper entries depending on wether tagpolicy is set', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithTagPolicyPrivilegesUsersManageTagsNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    const menu = wrapper.findAll('.moderation-dropdown-menu').at(0)
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual([
+      'users.disableAnySubscription',
+      'users.disableRemoteSubscription',
+      'users.forceNsfw',
+      'users.forceUnlisted',
+      'users.sandbox',
+      'users.stripMedia'
+    ])
+
+    store.state.users.mrfPolicies = []
+    await flushPromises()
+
+    expect(menu.findAll('.el-dropdown-menu__item').length).toEqual(0)
+
+    done()
+  })
+
+  it('shows enable tagpolicy for someone with users_manage_tags privilege and admin role when tagpolicy is not set', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithTagPolicyPrivilegesUsersManageTagsRolesAdmin))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    const menu = wrapper.findAll('.moderation-dropdown-menu').at(0)
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text())
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text.includes('users.disableAnySubscription')).toBe(true)
+    expect(menu_items_text.includes('users.disableRemoteSubscription')).toBe(true)
+    expect(menu_items_text.includes('users.forceNsfw')).toBe(true)
+    expect(menu_items_text.includes('users.forceUnlisted')).toBe(true)
+    expect(menu_items_text.includes('users.sandbox')).toBe(true)
+    expect(menu_items_text.includes('users.stripMedia')).toBe(true)
+
+    store.state.users.mrfPolicies = []
+    await flushPromises()
+
+    const menu_items_text_no_policy = menu.findAll('.el-dropdown-menu__item').wrappers.map(menu_item => menu_item.text())
+    expect(menu_items_text_no_policy.includes('users.disableAnySubscription')).toBe(false)
+    expect(menu_items_text_no_policy.includes('users.disableRemoteSubscription')).toBe(false)
+    expect(menu_items_text_no_policy.includes('users.forceNsfw')).toBe(false)
+    expect(menu_items_text_no_policy.includes('users.forceUnlisted')).toBe(false)
+    expect(menu_items_text_no_policy.includes('users.sandbox')).toBe(false)
+    expect(menu_items_text_no_policy.includes('users.stripMedia')).toBe(false)
+
+    expect(menu_items_text_no_policy.includes('users.enableTagPolicy')).toBe(true)
+
+    done()
+  })
+
+  it('shows for someone with users_manage_credentials privilege and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithPrivilegesUsersManageCredentialsNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    const menu = wrapper.findAll('.moderation-dropdown-menu').at(0)
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual(['users.getPasswordResetToken'])
+
+    done()
+  })
+})

test/views/users/components/MultipleUsersMenu.test.js

+import Vuex from 'vuex'
+import { mount, createLocalVue, config, RouterLinkStub } from '@vue/test-utils'
+import flushPromises from 'flush-promises'
+import Element from 'element-ui'
+import Users from '@/views/users/index'
+import {
+  storeNoPrivilegesNoRoles,
+  storeWithTagPolicyNoPrivilegesRolesAdmin,
+  storeWithPrivilegesUsersManageInvitesNoRoles,
+  storeWithPrivilegesUsersDeleteNoRoles,
+  storeWithPrivilegesUsersManageActivationStateNoRoles,
+  storeWithTagPolicyPrivilegesUsersManageTagsNoRoles,
+  storeWithTagPolicyPrivilegesUsersManageTagsRolesAdmin
+} from './store.conf'
+import { cloneDeep } from 'lodash'
+
+config.mocks["$t"] = (key) => key
+
+const localVue = createLocalVue()
+localVue.use(Vuex)
+localVue.use(Element)
+
+jest.mock('@/api/app')
+jest.mock('@/api/nodeInfo')
+jest.mock('@/api/users')
+jest.mock('@/api/settings')
+
+describe('The Multiple Users Moderation Menu', () => {
+  it('doesnt show for someone with no privileges and no roles', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeNoPrivilegesNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+
+    expect(wrapper.find('.multiple-users-menu').exists()).toEqual(false)
+    done()
+  })
+
+  it('shows for someone with admin role and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithTagPolicyNoPrivilegesRolesAdmin))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    await wrapper.find('.el-table').findAll('input').at(1).setChecked()
+    const menu = wrapper.find('.multiple-users-menu')
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual([
+      'users.confirmAccounts',
+      'users.grantAdmin',
+      'users.grantModerator',
+      'users.requirePasswordReset',
+      'users.resendConfirmation',
+      'users.revokeAdmin',
+      'users.revokeModerator'
+    ])
+
+    store.state.users.mrfPolicies = []
+    await flushPromises()
+
+    expect(menu_items.length).toEqual(7)
+    done()
+  })
+
+  it('shows for someone with users_manage_invites privilege and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithPrivilegesUsersManageInvitesNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    await wrapper.find('.el-table').findAll('input').at(1).setChecked()
+    const menu = wrapper.find('.multiple-users-menu')
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text())
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual(['users.approveAccounts'])
+    done()
+  })
+
+  it('shows for someone with users_delete privilege and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithPrivilegesUsersDeleteNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    await wrapper.find('.el-table').findAll('input').at(1).setChecked()
+    const menu = wrapper.find('.multiple-users-menu')
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual(['users.deleteAccounts', 'users.rejectAccounts'])
+    done()
+  })
+
+  it('shows for someone with users_manage_activation_state privilege and shows proper entries', async (done) => {
+    const store = new Vuex.Store(cloneDeep(storeWithPrivilegesUsersManageActivationStateNoRoles))
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+    await wrapper.find('.el-table').findAll('input').at(1).setChecked()
+    const menu = wrapper.find('.multiple-users-menu')
+    const menu_items = menu.findAll('.el-dropdown-menu__item')
+    const menu_items_text = menu_items.wrappers.map(menu_item => menu_item.text()).sort()
+
+    expect(menu.isVisible()).toEqual(true)
+    expect(menu_items_text).toEqual(['users.activateAccounts', 'users.deactivateAccounts'])
+    done()
+  })
+
+  it('shows for someone with users_manage_tags privilege and shows proper entries for non-admin/admin and with/without TagPolicy enabled', async (done) => {
+    const store_no_admin = new Vuex.Store(cloneDeep(storeWithTagPolicyPrivilegesUsersManageTagsNoRoles))
+    const wrapper_no_admin = mount(Users, {
+      store: store_no_admin,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    const store_admin = new Vuex.Store(cloneDeep(storeWithTagPolicyPrivilegesUsersManageTagsRolesAdmin))
+    const wrapper_admin = mount(Users, {
+      store: store_admin,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+
+    await flushPromises()
+    await wrapper_no_admin.find('.el-table').findAll('input').at(1).setChecked()
+    await wrapper_admin.find('.el-table').findAll('input').at(1).setChecked()
+    const menu_no_admin = wrapper_no_admin.find('.multiple-users-menu')
+    const menu_admin = wrapper_admin.find('.multiple-users-menu')
+    const menu_no_admin_items = menu_no_admin.findAll('.el-dropdown-menu__item')
+    const menu_admin_items = menu_admin.findAll('.el-dropdown-menu__item')
+    const filter = menu_item => { return menu_item.find('.tag-container .tag-text').exists() && menu_item.find('.tag-container .tag-text').text() }
+    const menu_no_admin_items_text = menu_no_admin_items.wrappers.map(filter).sort()
+    const menu_admin_items_text = menu_admin_items.wrappers.map(filter)
+
+    expect(menu_no_admin.isVisible()).toEqual(true)
+    expect(menu_no_admin_items_text).toEqual([
+      'users.disableAnySubscriptionForMultiple',
+      'users.disableRemoteSubscriptionForMultiple',
+      'users.forceNsfw',
+      'users.forceUnlisted',
+      'users.sandbox',
+      'users.stripMedia'
+    ])
+
+    expect(menu_admin.isVisible()).toEqual(true)
+    expect(menu_admin_items_text.includes('users.forceNsfw')).toBe(true)
+    expect(menu_admin_items_text.includes('users.stripMedia')).toBe(true)
+    expect(menu_admin_items_text.includes('users.forceUnlisted')).toBe(true)
+    expect(menu_admin_items_text.includes('users.sandbox')).toBe(true)
+    expect(menu_admin_items_text.includes('users.disableRemoteSubscriptionForMultiple')).toBe(true)
+    expect(menu_admin_items_text.includes('users.disableAnySubscriptionForMultiple')).toBe(true)
+
+    store_no_admin.state.users.mrfPolicies = []
+    store_admin.state.users.mrfPolicies = []
+    await flushPromises()
+
+    // Only an admin with users_manage_tags privilege can enable TagPolicy from the menu
+    expect(menu_no_admin.findAll('.el-dropdown-menu__item').length).toEqual(0)
+    expect(menu_admin.findAll('.el-dropdown-menu__item').wrappers.map(wrapper => wrapper.text()).includes('users.enableTagPolicy')).toBe(true)
+    done()
+  })
+})

test/views/users/components/store.conf.js

+import app from '@/store/modules/app'
+import settings from '@/store/modules/settings'
+import user from '@/store/modules/user'
+import userProfile from '@/store/modules/userProfile'
+import users from '@/store/modules/users'
+import getters from '@/store/getters'
+
+export const storeNoPrivilegesNoRoles = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: [],
+        privileges: []
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}
+
+export const storeWithTagPolicyNoPrivilegesRolesAdmin = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: ['admin'],
+        privileges: []
+      }
+    },
+    userProfile,
+    users: { ...users, state: { ...users.state, mrfPolicies: ['Pleroma.Web.ActivityPub.MRF.TagPolicy'] }}
+  },
+  getters
+}
+
+export const storeWithPrivilegesUsersManageInvitesNoRoles = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: [],
+        privileges: ['users_manage_invites']
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}
+
+export const storeWithPrivilegesUsersDeleteNoRoles = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: [],
+        privileges: ['users_delete']
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}
+
+export const storeWithPrivilegesUsersManageActivationStateNoRoles = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: [],
+        privileges: ['users_manage_activation_state']
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}
+
+export const storeWithTagPolicyPrivilegesUsersManageTagsNoRoles = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: [],
+        privileges: ['users_manage_tags']
+      }
+    },
+    userProfile,
+    users: { ...users, state: { ...users.state, mrfPolicies: ['Pleroma.Web.ActivityPub.MRF.TagPolicy'] }}
+  },
+  getters
+}
+
+export const storeWithTagPolicyPrivilegesUsersManageTagsRolesAdmin = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: ['admin'],
+        privileges: ['users_manage_tags']
+      }
+    },
+    userProfile,
+    users: { ...users, state: { ...users.state, mrfPolicies: ['Pleroma.Web.ActivityPub.MRF.TagPolicy'] }}
+  },
+  getters
+}
+
+export const storeWithPrivilegesUsersManageCredentialsNoRoles = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: [],
+        privileges: ['users_manage_credentials']
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}

test/views/users/index.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import Vuex from 'vuex'
-import { mount, createLocalVue, config } from '@vue/test-utils'
+import { mount, createLocalVue, config, RouterLinkStub } from '@vue/test-utils'
 import flushPromises from 'flush-promises'
 import Element from 'element-ui'
 import Users from '@/views/users/index'
 import NewAccountDialog from '@/views/users/components/NewAccountDialog'
-import storeConfig from './store.conf'
+import {
+  storeConfig,
+  storeWithRoleAdminNoPrivileges,
+  storeWithNoRolesNoPrivileges
+} from './store.conf'
 import { cloneDeep } from 'lodash'
 
 config.mocks["$t"] = () => {}
-config.stubs['users-filter'] = '<div />'
+config.stubs['users-filter'] = { template: '<div />'}
+config.stubs.transition = false
 
 const localVue = createLocalVue()
 localVue.use(Vuex)
 localVue.use(Element)
 
+jest.mock('@/api/app')
 jest.mock('@/api/nodeInfo')
 jest.mock('@/api/users')
+jest.mock('@/api/settings')
 
 describe('Search and filter users', () => {
   let store
@@ -29,11 +39,13 @@ describe('Search and filter users', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
 
     await flushPromises()
-    expect(wrapper.vm.usersCount).toEqual(3)
+    expect(wrapper.vm.usersCount).toEqual(6)
     done()
   })
 
@@ -42,7 +54,9 @@ describe('Search and filter users', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
 
     wrapper.vm.handleDebounceSearchInput = (query) => {
@@ -50,7 +64,7 @@ describe('Search and filter users', () => {
     }
 
     await flushPromises()
-    expect(wrapper.vm.usersCount).toEqual(3)
+    expect(wrapper.vm.usersCount).toEqual(6)
     const input = wrapper.find('.search input.el-input__inner')
     input.element.value = 'bob'
     input.trigger('input')
@@ -60,7 +74,7 @@ describe('Search and filter users', () => {
     input.element.value = ''
     input.trigger('input')
     await flushPromises()
-    expect(wrapper.vm.usersCount).toEqual(3)
+    expect(wrapper.vm.usersCount).toEqual(6)
 
     done()
   })
@@ -69,27 +83,55 @@ describe('Search and filter users', () => {
 describe('Users actions', () => {
   let store
   const htmlElement = (trChild, liChild) =>
-    `.el-table__fixed-body-wrapper table tr:nth-child(${trChild}) ul.el-dropdown-menu li:nth-child(${liChild})`
+    `.el-table__fixed-body-wrapper table tr:nth-child(${trChild}) ul.el-dropdown-menu > li:nth-child(${liChild})`
 
   beforeEach(() => {
     store = new Vuex.Store(cloneDeep(storeConfig))
   })
 
+  it('doesnt show create new account button if not privileged', async (done) => {
+    const wrapper_admin = mount(Users, {
+      store: new Vuex.Store(cloneDeep(storeWithRoleAdminNoPrivileges)),
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+
+    const wrapper_no_admin = mount(Users, {
+      store: new Vuex.Store(cloneDeep(storeWithNoRolesNoPrivileges)),
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+
+    await flushPromises()
+    expect(wrapper_admin.find('.actions-button').isVisible()).toBe(true)
+    expect(wrapper_no_admin.find('.actions-button').exists()).toBe(false)
+
+    done()
+  })
+
   it('grants admin right to a local user', async (done) => {
     const wrapper = mount(Users, {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
-    const user = store.state.users.fetchedUsers[2]
+    const user = store.state.users.fetchedUsers[1]
     expect(user.roles.admin).toBe(false)
     expect(user.roles.moderator).toBe(false)
-    wrapper.find(htmlElement(3, 1)).trigger('click')
+    wrapper.find(htmlElement(2, 2)).trigger('click')
 
-    const updatedUser = store.state.users.fetchedUsers[2]
+    const updatedUser = store.state.users.fetchedUsers[1]
     expect(updatedUser.roles.admin).toBe(true)
     done()
   })
@@ -99,16 +141,18 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
-    const user = store.state.users.fetchedUsers[2]
-    expect(user.roles.admin).toBe(false)
+    const user = store.state.users.fetchedUsers[0]
+    expect(user.roles.admin).toBe(true)
     expect(user.roles.moderator).toBe(false)
-    wrapper.find(htmlElement(3, 2)).trigger('click')
+    wrapper.find(htmlElement(1, 3)).trigger('click')
 
-    const updatedUser = store.state.users.fetchedUsers[2]
+    const updatedUser = store.state.users.fetchedUsers[0]
     expect(updatedUser.roles.moderator).toBe(true)
     done()
   })
@@ -118,14 +162,16 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
     const dropdownMenuItems = wrapper.findAll(
-      `.el-table__fixed-body-wrapper table tr:nth-child(2) ul.el-dropdown-menu li`
+      `.el-table__fixed-body-wrapper table tr:nth-child(3) ul.el-dropdown-menu > li`
     )
-    expect(dropdownMenuItems.length).toBe(6)
+    expect(dropdownMenuItems.length).toBe(7)
     done()
   })
 
@@ -134,16 +180,18 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
     const user = store.state.users.fetchedUsers[1]
-    expect(user.deactivated).toBe(false)
-    wrapper.find(htmlElement(2, 1)).trigger('click')
+    expect(user.is_active).toBe(true)
+    wrapper.find(htmlElement(2, 4)).trigger('click')
 
     const updatedUser = store.state.users.fetchedUsers[1]
-    expect(updatedUser.deactivated).toBe(true)
+    expect(updatedUser.is_active).toBe(false)
     done()
   })
 
@@ -152,14 +200,18 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
-    expect(store.state.users.fetchedUsers.length).toEqual(3)
+    expect(store.state.users.fetchedUsers[1].is_active).toBe(true)
+
+    wrapper.find(htmlElement(2, 5)).trigger('click')
+    store.dispatch('DeleteUsers', { users: [{ active: true, is_active: true, id: '10', nickname: 'bob', local: false, external: true, roles: { admin: false, moderator: false }, tags: ['mrf_tag:sandbox'] }] })
 
-    wrapper.find(htmlElement(2, 2)).trigger('click')
     await flushPromises()
-    expect(store.state.users.fetchedUsers.length).toEqual(2)
+    expect(store.state.users.fetchedUsers[1].is_active).toBe(false)
     done()
   })
 
@@ -168,7 +220,9 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
@@ -177,8 +231,8 @@ describe('Users actions', () => {
     expect(user1.tags.length).toBe(0)
     expect(user2.tags.length).toBe(1)
 
-    wrapper.find(htmlElement(1, 5)).trigger('click')
-    wrapper.find(htmlElement(2, 5)).trigger('click')
+    wrapper.find(htmlElement(1, 6)).trigger('click')
+    wrapper.find(htmlElement(2, 6)).trigger('click')
 
     const updatedUser1 = store.state.users.fetchedUsers[0]
     const updatedUser2 = store.state.users.fetchedUsers[1]
@@ -192,13 +246,15 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
     const user = store.state.users.fetchedUsers[1]
     expect(user.tags.length).toBe(1)
-    wrapper.find(htmlElement(2, 6)).trigger('click')
+    wrapper.find(htmlElement(2, 9)).trigger('click')
 
     const updatedUser = store.state.users.fetchedUsers[1]
     expect(updatedUser.tags.length).toBe(0)
@@ -210,7 +266,9 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
@@ -235,25 +293,27 @@ describe('Users actions', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
-    const dialog = wrapper.find('.password-reset-token-dialog')
+    wrapper.setData({ resetPasswordDialogOpen: false })
     const closeDialogButton = wrapper.find('.password-reset-token-dialog button')
-    expect(dialog.isVisible()).toBe(false)
+    expect(wrapper.vm.resetPasswordDialogOpen).toBe(false)
     expect(store.state.users.passwordResetToken.token).toBe('')
 
-    wrapper.find(htmlElement(1, 11)).trigger('click')
+    wrapper.find(htmlElement(1, 12)).trigger('click')
     await flushPromises()
 
-    expect(dialog.isVisible()).toBe(true)
+    expect(wrapper.vm.resetPasswordDialogOpen).toBe(true)
     expect(store.state.users.passwordResetToken.token).toBe('g05lxnBJQnL')
     expect(store.state.users.passwordResetToken.link).toBe('http://url/api/pleroma/password_reset/g05lxnBJQnL')
 
     closeDialogButton.trigger('click')
     await flushPromises()
-    expect(dialog.isVisible()).toBe(false)
+    expect(wrapper.vm.resetPasswordDialogOpen).toBe(false)
     done()
   })
 })
@@ -274,23 +334,24 @@ describe('Creates new account', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
 
-    const dialog = wrapper.find('div.el-dialog__wrapper')
-    expect(dialog.isVisible()).toBe(false)
-
+    wrapper.setData({ createAccountDialogOpen: false })
     const openDialogButton = wrapper.find('button.actions-button')
     const closeDialogButton = wrapper.find('div.el-dialog__footer button')
+    expect(wrapper.vm.createAccountDialogOpen).toBe(false)
 
     openDialogButton.trigger('click')
     await flushPromises()
-    expect(dialog.isVisible()).toBe(true)
+    expect(wrapper.vm.createAccountDialogOpen).toBe(true)
 
     closeDialogButton.trigger('click')
     await flushPromises()
-    expect(dialog.isVisible()).toBe(false)
+    expect(wrapper.vm.createAccountDialogOpen).toBe(false)
     done()
   })
 
@@ -299,10 +360,12 @@ describe('Creates new account', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
     await flushPromises()
-    expect(wrapper.vm.usersCount).toEqual(3)
+    expect(wrapper.vm.usersCount).toEqual(6)
 
     const openDialogButton = wrapper.find('button.actions-button')
     openDialogButton.trigger('click')
@@ -324,7 +387,7 @@ describe('Creates new account', () => {
     createButton.trigger('click')
     await flushPromises()
 
-    expect(wrapper.vm.usersCount).toEqual(4)
+    expect(wrapper.vm.usersCount).toEqual(7)
     done()
   })
 
@@ -333,7 +396,9 @@ describe('Creates new account', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link']
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
     })
 
     const validateEmailRule = { validator: wrapper.vm.validateEmail, field: 'email', fullField: 'email', type: 'string' }
@@ -351,7 +416,28 @@ describe('Creates new account', () => {
 
     expect(wrapper.vm.validatePassword(validatePasswordRule, '', identity)).toBeInstanceOf(Error)
     expect(wrapper.vm.validatePassword(validatePasswordRule, '1234', identity)).toBeUndefined()
+  })
 
+  it('updates actor type', async (done) => {
+    const wrapper = mount(Users, {
+      store,
+      localVue,
+      sync: false,
+      stubs: {
+        RouterLink: RouterLinkStub
+      }
+    })
+    await flushPromises()
+
+    const user = store.state.users.fetchedUsers[0]
+    expect(user.actor_type).toBe('Person')
 
+    const findWrapper = (trChild, liChild1, liChild2) =>
+    `.el-table__fixed-body-wrapper table tr:nth-child(${trChild}) ul.el-dropdown-menu > li:nth-child(${liChild1}) ul li:nth-child(${liChild2})`
+    wrapper.find(findWrapper(1, 1, 1)).trigger('click')
+
+    const updatedUser = store.state.users.fetchedUsers[0]
+    expect(updatedUser.actor_type).toBe('Service')
+    done()
   })
 })

test/views/users/multipleUsersMenu.test.js

-import Vuex from 'vuex'
-import { mount, createLocalVue, config } from '@vue/test-utils'
-import Element from 'element-ui'
-import MultipleUsersMenu from '@/views/users/components/MultipleUsersMenu'
-import storeConfig from './store.conf'
-import { cloneDeep } from 'lodash'
-import flushPromises from 'flush-promises'
-import { users } from '@/api/__mocks__/users.js'
-
-config.mocks["$t"] = () => {}
-
-const localVue = createLocalVue()
-localVue.use(Vuex)
-localVue.use(Element)
-
-jest.mock('@/api/nodeInfo')
-jest.mock('@/api/users')
-
-describe('Apply users actions to multiple users', () => {
-  let store
-
-  beforeEach(async() => {
-    store = new Vuex.Store(cloneDeep(storeConfig))
-    store.dispatch('FetchUsers', { page: 1 })
-    await flushPromises()
-  })
-
-  it('grants admin rights to multiple users', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const grantRightToMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ grantRightToMultipleUsers: grantRightToMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(1)`).trigger('click')
-    expect(wrapper.vm.grantRightToMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.grantRightToMultipleUsers).toHaveBeenCalledWith('admin')
-
-    const grantRight = wrapper.vm.mappers().grantRight
-    const user1 = store.state.users.fetchedUsers[0]
-    const user2 = store.state.users.fetchedUsers[1]
-    const user3 = store.state.users.fetchedUsers[2]
-    expect(user1.roles.admin).toBe(true)
-    expect(user2.roles.admin).toBe(false)
-    expect(user3.roles.admin).toBe(false)
-    grantRight('admin')()
-
-    const updatedUser1 = store.state.users.fetchedUsers[0]
-    const updatedUser2 = store.state.users.fetchedUsers[1]
-    const updatedUser3 = store.state.users.fetchedUsers[2]
-    expect(updatedUser1.roles.admin).toBe(true)
-    expect(updatedUser2.roles.admin).toBe(false)
-    expect(updatedUser3.roles.admin).toBe(true)
-    done()
-  })
-
-  it('grants moderator rights to multiple users', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const grantRightToMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ grantRightToMultipleUsers: grantRightToMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(3)`).trigger('click')
-    expect(wrapper.vm.grantRightToMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.grantRightToMultipleUsers).toHaveBeenCalledWith('moderator')
-
-    const grantRight = wrapper.vm.mappers().grantRight
-    const user1 = store.state.users.fetchedUsers[0]
-    const user2 = store.state.users.fetchedUsers[1]
-    const user3 = store.state.users.fetchedUsers[2]
-    expect(user1.roles.moderator).toBe(false)
-    expect(user2.roles.moderator).toBe(false)
-    expect(user3.roles.moderator).toBe(false)
-    grantRight('moderator')()
-
-    const updatedUser1 = store.state.users.fetchedUsers[0]
-    const updatedUser2 = store.state.users.fetchedUsers[1]
-    const updatedUser3 = store.state.users.fetchedUsers[2]
-    expect(updatedUser1.roles.moderator).toBe(true)
-    expect(updatedUser2.roles.moderator).toBe(false)
-    expect(updatedUser3.roles.moderator).toBe(true)
-    done()
-  })
-
-  it('revokes admin rights from multiple users', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const revokeRightFromMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ revokeRightFromMultipleUsers: revokeRightFromMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(2)`).trigger('click')
-    expect(wrapper.vm.revokeRightFromMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.revokeRightFromMultipleUsers).toHaveBeenCalledWith('admin')
-
-    const revokeRight = wrapper.vm.mappers().revokeRight
-    const user1 = store.state.users.fetchedUsers[0]
-    const user2 = store.state.users.fetchedUsers[2]
-    expect(user1.roles.admin).toBe(true)
-    expect(user2.roles.admin).toBe(false)
-    revokeRight('admin')()
-
-    const updatedUser1 = store.state.users.fetchedUsers[0]
-    const updatedUser2 = store.state.users.fetchedUsers[2]
-    expect(updatedUser1.roles.admin).toBe(false)
-    expect(updatedUser2.roles.admin).toBe(false)
-    done()
-  })
-
-  it('calls a function that revokes moderator rights from multiple users', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const revokeRightFromMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ revokeRightFromMultipleUsers: revokeRightFromMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(4)`).trigger('click')
-    expect(wrapper.vm.revokeRightFromMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.revokeRightFromMultipleUsers).toHaveBeenCalledWith('moderator')
-    done()
-  })
-
-  it('activates multiple accounts', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const activateMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ activateMultipleUsers: activateMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(7)`).trigger('click')
-    expect(wrapper.vm.activateMultipleUsers).toHaveBeenCalled()
-
-    const activate = wrapper.vm.mappers().activate
-    const user = store.state.users.fetchedUsers[2]
-    expect(user.deactivated).toBe(true)
-    activate()
-
-    const updatedUser = store.state.users.fetchedUsers[2]
-    expect(updatedUser.deactivated).toBe(false)
-    done()
-  })
-
-  it('deactivates multiple accounts', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const deactivateMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ deactivateMultipleUsers: deactivateMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(8)`).trigger('click')
-    expect(wrapper.vm.deactivateMultipleUsers).toHaveBeenCalled()
-
-    const deactivate = wrapper.vm.mappers().deactivate
-    const user1 = store.state.users.fetchedUsers[0]
-    const user2 = store.state.users.fetchedUsers[1]
-    expect(user1.deactivated).toBe(false)
-    expect(user2.deactivated).toBe(false)
-    deactivate()
-
-    const updatedUser1 = store.state.users.fetchedUsers[0]
-    const updatedUser2 = store.state.users.fetchedUsers[1]
-    expect(updatedUser1.deactivated).toBe(true)
-    expect(updatedUser2.deactivated).toBe(true)
-    done()
-  })
-
-  it('deletes multiple accounts', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const deleteMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ deleteMultipleUsers: deleteMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(9)`).trigger('click')
-    expect(wrapper.vm.deleteMultipleUsers).toHaveBeenCalled()
-
-    const remove = wrapper.vm.mappers().remove
-    expect(store.state.users.fetchedUsers.length).toEqual(3)
-    remove()
-    await flushPromises()
-
-    expect(store.state.users.fetchedUsers.length).toEqual(0)
-    done()
-  })
-
-  it('applies tags for multiple accounts', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const addTagForMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ addTagForMultipleUsers: addTagForMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(11) button:nth-child(1)`).trigger('click')
-    expect(wrapper.vm.addTagForMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.addTagForMultipleUsers).toHaveBeenCalledWith('force_nsfw')
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(13) button:nth-child(1)`).trigger('click')
-    expect(wrapper.vm.addTagForMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.addTagForMultipleUsers).toHaveBeenCalledWith('force_unlisted')
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(15  ) button:nth-child(1)`).trigger('click')
-    expect(wrapper.vm.addTagForMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.addTagForMultipleUsers).toHaveBeenCalledWith('disable_remote_subscription')
-
-    const addTag = wrapper.vm.mappers().addTag
-    const user1 = store.state.users.fetchedUsers[0]
-    const user2 = store.state.users.fetchedUsers[1]
-    expect(user1.tags.length).toBe(0)
-    expect(user2.tags.length).toBe(1)
-    addTag('strip_media')()
-
-    const updatedUser1 = store.state.users.fetchedUsers[0]
-    const updatedUser2 = store.state.users.fetchedUsers[1]
-    expect(updatedUser1.tags.length).toBe(1)
-    expect(updatedUser2.tags.length).toBe(2)
-    done()
-  })
-
-  it('removes tags from multiple accounts', async (done) => {
-    const wrapper = mount(MultipleUsersMenu, {
-      store,
-      localVue,
-      sync: false,
-      propsData: {
-        selectedUsers: users
-      }
-    })
-    await flushPromises()
-
-    const removeTagFromMultipleUsersStub = jest.fn()
-    wrapper.setMethods({ removeTagFromMultipleUsers: removeTagFromMultipleUsersStub })
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(12) button:nth-child(2)`).trigger('click')
-    expect(wrapper.vm.removeTagFromMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.removeTagFromMultipleUsers).toHaveBeenCalledWith('strip_media')
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(14) button:nth-child(2)`).trigger('click')
-    expect(wrapper.vm.removeTagFromMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.removeTagFromMultipleUsers).toHaveBeenCalledWith('sandbox')
-
-    wrapper.find(`.el-dropdown-menu__item:nth-child(16) button:nth-child(2)`).trigger('click')
-    expect(wrapper.vm.removeTagFromMultipleUsers).toHaveBeenCalled()
-    expect(wrapper.vm.removeTagFromMultipleUsers).toHaveBeenCalledWith('disable_any_subscription')
-
-    const removeTag = wrapper.vm.mappers().removeTag
-    const user1 = store.state.users.fetchedUsers[1]
-    const user2 = store.state.users.fetchedUsers[2]
-    expect(user1.tags.length).toBe(1)
-    expect(user2.tags.length).toBe(1)
-    removeTag('strip_media')()
-
-    const updatedUser1 = store.state.users.fetchedUsers[1]
-    const updatedUser2 = store.state.users.fetchedUsers[2]
-    expect(updatedUser1.tags.length).toBe(1)
-    expect(updatedUser2.tags.length).toBe(0)
-    done()
-  })
-})

test/views/users/show.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import Vuex from 'vuex'
-import { mount, createLocalVue, config } from '@vue/test-utils'
+import { mount, createLocalVue, config, RouterLinkStub } from '@vue/test-utils'
 import flushPromises from 'flush-promises'
 import Element from 'element-ui'
 import UsersShow from '@/views/users/show'
-import storeConfig from './store.conf'
+import { storeConfig } from './store.conf'
 import { cloneDeep } from 'lodash'
 
 config.mocks["$t"] = () => {}
+config.stubs.transition = false
 
 const localVue = createLocalVue()
 localVue.use(Vuex)
@@ -18,10 +22,12 @@ const $route = {
   }
 }
 
+jest.mock('@/api/app')
 jest.mock('@/api/nodeInfo')
 jest.mock('@/api/users')
+jest.mock('@/api/settings')
 
-describe('Search and filter users', () => {
+describe('User profile', () => {
   let store
 
   beforeEach(() => {
@@ -33,7 +39,9 @@ describe('Search and filter users', () => {
       store,
       localVue,
       sync: false,
-      stubs: ['router-link'],
+      stubs: {
+        RouterLink: RouterLinkStub
+      },
       mocks: {
         $route
       }

test/views/users/store.conf.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import app from '@/store/modules/app'
+import settings from '@/store/modules/settings'
 import user from '@/store/modules/user'
 import userProfile from '@/store/modules/userProfile'
 import users from '@/store/modules/users'
 import getters from '@/store/getters'
 
-export default {
+export const storeConfig = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: ['admin'],
+        privileges: ['users_manage_activation_state', 'users_delete', 'users_manage_tags', 'users_manage_credentials']
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}
+
+export const storeWithTagPolicy = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: ['admin'],
+        privileges: ['users_manage_activation_state', 'users_delete', 'users_manage_tags', 'users_manage_credentials']
+      }
+    },
+    userProfile,
+    users: {
+      ...users,
+      state: {
+        ...users.state,
+        mrfPolicies: ['Pleroma.Web.ActivityPub.MRF.TagPolicy']
+      }
+    }
+  },
+  getters
+}
+
+export const storeWithRoleAdminNoPrivileges = {
+  modules: {
+    app,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: ['admin'],
+        privileges: []
+      }
+    },
+    userProfile,
+    users
+  },
+  getters
+}
+
+
+export const storeWithNoRolesNoPrivileges = {
   modules: {
     app,
-    user,
+    settings,
+    user: {
+      ...user,
+      state: {
+        ...user.state,
+        roles: [],
+        privileges: []
+      }
+    },
     userProfile,
     users
   },

test/views/users/usersFilters.test.js

+// SPDX-FileCopyrightText: 2019-2022 Pleroma Authors <https://pleroma.social>
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import Vuex from 'vuex'
 import { mount, createLocalVue, config } from '@vue/test-utils'
 import Element from 'element-ui'
 import Filters from '@/views/users/components/UsersFilter'
-import storeConfig from './store.conf'
-import { cloneDeep } from 'lodash'
 import flushPromises from 'flush-promises'
+import app from '@/store/modules/app'
+import settings from '@/store/modules/settings'
+import user from '@/store/modules/user'
+import userProfile from '@/store/modules/userProfile'
+import users from '@/store/modules/users'
 
 config.mocks["$t"] = () => {}
 config.stubs.transition = false
@@ -13,79 +19,150 @@ const localVue = createLocalVue()
 localVue.use(Vuex)
 localVue.use(Element)
 
+jest.mock('@/api/app')
 jest.mock('@/api/nodeInfo')
+jest.mock('@/api/settings')
 jest.mock('@/api/users')
 
 describe('Filters users', () => {
   let store
+  let actions
 
   beforeEach(async() => {
-    store = new Vuex.Store(cloneDeep(storeConfig))
+    actions = { ...users.actions, ToggleUsersFilter: jest.fn(), ToggleActorTypeFilter: jest.fn() }
+    store = new Vuex.Store(({ 
+      modules: {
+        app,
+        settings,
+        user,
+        userProfile,
+        users: { ...users, actions }
+      },
+      getters: {}
+    }))
     store.dispatch('FetchUsers', { page: 1 })
     await flushPromises()
   })
 
-  it('shows local users when "Local" filter is applied', async (done) => {
+  it('enables local and active filters when component is mounted, toggles local filter on button click', async (done) => {
     const wrapper = mount(Filters, {
       store,
       localVue
     })
-
-    expect(store.state.users.totalUsersCount).toEqual(3)
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(1, expect.anything(), ['local', 'active'], undefined)
 
     const filter = wrapper.find(`li.el-select-dropdown__item:nth-child(${1})`)
     filter.trigger('click')
-    await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(2)
 
+    expect(actions.ToggleUsersFilter).toHaveBeenCalled()
+    expect(actions.ToggleActorTypeFilter).toHaveBeenCalled()
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(2, expect.anything(), ['active'], undefined)
+    expect(actions.ToggleActorTypeFilter).toHaveBeenCalledWith(expect.anything(), [], undefined)
+    await flushPromises()
     done()
   })
 
-  it('shows users with applied filter and search query', async (done) => {
-    expect(store.state.users.totalUsersCount).toEqual(3)
+  it('applies three filters', async (done) => {
+    const wrapper = mount(Filters, {
+      store,
+      localVue
+    })
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(1, expect.anything(), ['local', 'active'], undefined)
+    
+    const filter1 = wrapper.find(`.el-select-group__wrap:nth-child(${1}) li.el-select-dropdown__item:nth-child(${2})`)
+    filter1.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(2, expect.anything(), ['external', 'active'], undefined)
+    expect(actions.ToggleActorTypeFilter).toHaveBeenCalledWith(expect.anything(), [], undefined)
+    await flushPromises()
 
-    store.dispatch('ToggleUsersFilter', { active: true })
+    const filter2 = wrapper.find(`.el-select-group__wrap:nth-child(${2}) li.el-select-dropdown__item:nth-child(${3})`)
+    filter2.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(3, expect.anything(), ['external', 'need_approval'], undefined)
+    expect(actions.ToggleActorTypeFilter).toHaveBeenCalledWith(expect.anything(), [], undefined)
     await flushPromises()
-    store.dispatch('SearchUsers', { query: 'john', page: 1 })
+
+    const filter3 = wrapper.find(`.el-select-group__wrap:nth-child(${3}) li.el-select-dropdown__item:nth-child(${1})`)
+    filter3.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(4, expect.anything(), ['external', 'need_approval'], undefined)
+    expect(actions.ToggleActorTypeFilter).toHaveBeenCalledWith(expect.anything(), ['Person'], undefined)
     await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(0)
+    done()
+  })
 
-    store.dispatch('SearchUsers', { query: 'allis', page: 1 })
+  it('removes all filters', async (done) => {
+    const wrapper = mount(Filters, {
+      store,
+      localVue
+    })
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(1, expect.anything(), ['local', 'active'], undefined)
+    
+    const filter1 = wrapper.find(`.el-select-group__wrap:nth-child(${1}) li.el-select-dropdown__item:nth-child(${1})`)
+    filter1.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(2, expect.anything(), ['active'], undefined)
+    expect(actions.ToggleActorTypeFilter).toHaveBeenCalledWith(expect.anything(), [], undefined)
     await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(1)
 
-    store.dispatch('SearchUsers', { query: '', page: 1 })
+    const filter2 = wrapper.find(`.el-select-group__wrap:nth-child(${2}) li.el-select-dropdown__item:nth-child(${1})`)
+    filter2.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(3, expect.anything(), [], undefined)
+    expect(actions.ToggleActorTypeFilter).toHaveBeenCalledWith(expect.anything(), [], undefined)
     await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(2)
 
     done()
   })
 
-  it('applies two filters', async (done) => {
-    expect(store.state.users.totalUsersCount).toEqual(3)
+  it('applies actor type filters', async (done) => {
+    const wrapper = mount(Filters, {
+      store,
+      localVue
+    })
+    
+    const filter1 = wrapper.find(`.el-select-group__wrap:nth-child(${3}) li.el-select-dropdown__item:nth-child(${1})`)
+    filter1.trigger('click')
+    expect(actions.ToggleActorTypeFilter).toHaveBeenNthCalledWith(1, expect.anything(), ['Person'], undefined)
+    await flushPromises()
 
-    store.dispatch('ToggleUsersFilter', { active: true, local: true })
+    const filter2 = wrapper.find(`.el-select-group__wrap:nth-child(${3}) li.el-select-dropdown__item:nth-child(${2})`)
+    filter2.trigger('click')
+    expect(actions.ToggleActorTypeFilter).toHaveBeenNthCalledWith(2, expect.anything(), ['Person', 'Service'], undefined)
     await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(1)
-    expect(store.state.users.fetchedUsers[0].nickname).toEqual('allis')
 
-    store.dispatch('ToggleUsersFilter', { deactivated: true, external: true })
+    const filter3 = wrapper.find(`.el-select-group__wrap:nth-child(${3}) li.el-select-dropdown__item:nth-child(${3})`)
+    filter3.trigger('click')
+    expect(actions.ToggleActorTypeFilter).toHaveBeenNthCalledWith(3, expect.anything(), ['Person', 'Service', 'Application'], undefined)
     await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(0)
 
     done()
   })
 
-  it('shows all users after removing filters', async (done) => {
-    expect(store.state.users.totalUsersCount).toEqual(3)
+  it('applies opposite filters', async (done) => {
+    const wrapper = mount(Filters, {
+      store,
+      localVue
+    })
+
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(1, expect.anything(), ['local', 'active'], undefined)
+    
+    const filter1 = wrapper.find(`.el-select-group__wrap:nth-child(${2}) li.el-select-dropdown__item:nth-child(${2})`)
+    filter1.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(2, expect.anything(), ['local', 'deactivated'], undefined)
+    await flushPromises()
 
-    store.dispatch('ToggleUsersFilter', { deactivated: true })
+    const filter2 = wrapper.find(`.el-select-group__wrap:nth-child(${2}) li.el-select-dropdown__item:nth-child(${3})`)
+    filter2.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(3, expect.anything(), ['local', 'need_approval'], undefined)
     await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(1)
 
-    store.dispatch('ToggleUsersFilter', {})
+    const filter3 = wrapper.find(`.el-select-group__wrap:nth-child(${2}) li.el-select-dropdown__item:nth-child(${4})`)
+    filter3.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(4, expect.anything(), ['local', 'unconfirmed'], undefined)
     await flushPromises()
-    expect(store.state.users.totalUsersCount).toEqual(3)
+
+    const filter4 = wrapper.find(`.el-select-group__wrap:nth-child(${1}) li.el-select-dropdown__item:nth-child(${2})`)
+    filter4.trigger('click')
+    expect(actions.ToggleUsersFilter).toHaveBeenNthCalledWith(5, expect.anything(), ['external', 'unconfirmed'], undefined)
+    await flushPromises()
+
 
     done()
   })