Merge branch 'develop' into setttingssync

test/unit/specs/boot/routes.spec.js

@@ -1,13 +1,12 @@
 import { createTestingPinia } from '@pinia/testing'
+
+createTestingPinia()
+
 import { createMemoryHistory, createRouter } from 'vue-router'
 import { createStore } from 'vuex'
 
-import { useInstanceStore } from 'src/stores/instance.js'
-
 import routes from 'src/boot/routes'
 
-useInstanceStore(createTestingPinia())
-
 const store = createStore({
   state: {
     instance: {},

test/unit/specs/components/draft.spec.js

@@ -5,8 +5,6 @@ import { nextTick } from 'vue'
 import PostStatusForm from 'src/components/post_status_form/post_status_form.vue'
 import { $t, mountOpts, waitForEvent } from '../../../fixtures/setup_test'
 
-import { useSyncConfigStore } from 'src/stores/sync_config.js'
-
 const autoSaveOrNot = (caseFn, caseTitle, runFn) => {
   caseFn(`${caseTitle} with auto-save`, function () {
     return runFn.bind(this)(true)
@@ -33,23 +31,22 @@ const saveManually = async (wrapper) => {
 
 const waitSaveTime = 4000
 
-describe('Draft saving', () => {
-  beforeEach(() => {
-    const store = useSyncConfigStore(createTestingPinia())
-    store.mergedConfig = {
-      autoSaveDraft: true,
-    }
-  })
+afterEach(() => {
+  vi.useRealTimers()
+})
 
-  afterEach(() => {
-    vi.useRealTimers()
-  })
+describe('Draft saving', () => {
+  createTestingPinia()
 
   autoSaveOrNot(
     it,
     'should save when the button is clicked',
     async (autoSave) => {
       const wrapper = mount(PostStatusForm, mountOpts())
+      await wrapper.vm.$store.dispatch('setOption', {
+        name: 'autoSaveDraft',
+        value: autoSave,
+      })
       expect(wrapper.vm.$store.getters.draftCount).to.equal(0)
 
       const textarea = wrapper.get('textarea')
@@ -89,6 +86,10 @@ describe('Draft saving', () => {
         },
       }),
     )
+    await wrapper.vm.$store.dispatch('setOption', {
+      name: 'autoSaveDraft',
+      value: true,
+    })
     expect(wrapper.vm.$store.getters.draftCount).to.equal(0)
     const textarea = wrapper.get('textarea')
     await textarea.setValue('mew mew')
@@ -106,11 +107,14 @@ describe('Draft saving', () => {
         },
       }),
     )
-    const store = useSyncConfigStore(createTestingPinia())
-    store.mergedConfig = {
-      autoSaveDraft: false,
-      unsavedPostAction: 'save',
-    }
+    await wrapper.vm.$store.dispatch('setOption', {
+      name: 'autoSaveDraft',
+      value: false,
+    })
+    await wrapper.vm.$store.dispatch('setOption', {
+      name: 'unsavedPostAction',
+      value: 'save',
+    })
     expect(wrapper.vm.$store.getters.draftCount).to.equal(0)
     const textarea = wrapper.get('textarea')
     await textarea.setValue('mew mew')
@@ -128,11 +132,14 @@ describe('Draft saving', () => {
         },
       }),
     )
-    const store = useSyncConfigStore(createTestingPinia())
-    store.mergedConfig = {
-      autoSaveDraft: false,
-      unsavedPostAction: 'discard',
-    }
+    await wrapper.vm.$store.dispatch('setOption', {
+      name: 'autoSaveDraft',
+      value: false,
+    })
+    await wrapper.vm.$store.dispatch('setOption', {
+      name: 'unsavedPostAction',
+      value: 'discard',
+    })
     expect(wrapper.vm.$store.getters.draftCount).to.equal(0)
     const textarea = wrapper.get('textarea')
     await textarea.setValue('mew mew')
@@ -150,11 +157,14 @@ describe('Draft saving', () => {
         },
       }),
     )
-    const store = useSyncConfigStore(createTestingPinia())
-    store.mergedConfig = {
-      autoSaveDraft: false,
-      unsavedPostAction: 'confirm',
-    }
+    await wrapper.vm.$store.dispatch('setOption', {
+      name: 'autoSaveDraft',
+      value: false,
+    })
+    await wrapper.vm.$store.dispatch('setOption', {
+      name: 'unsavedPostAction',
+      value: 'confirm',
+    })
     expect(wrapper.vm.$store.getters.draftCount).to.equal(0)
     const textarea = wrapper.get('textarea')
     await textarea.setValue('mew mew')

test/unit/specs/components/emoji_input.spec.js

@@ -3,6 +3,8 @@ import { shallowMount } from '@vue/test-utils'
 import vClickOutside from 'click-outside-vue3'
 import { h } from 'vue'
 
+createTestingPinia()
+
 import EmojiInput from 'src/components/emoji_input/emoji_input.vue'
 
 import { useSyncConfigStore } from 'src/stores/sync_config.js'

test/unit/specs/modules/statuses.spec.js

@@ -1,9 +1,13 @@
+import { createTestingPinia } from '@pinia/testing'
+
 import {
   defaultState,
   mutations,
   prepareStatus,
 } from '../../../../src/modules/statuses.js'
 
+createTestingPinia()
+
 const makeMockStatus = ({ id, text, type = 'status' }) => {
   return {
     id,

test/unit/specs/stores/oauth.spec.js

@@ -1,7 +1,6 @@
+import { createTestingPinia } from '@pinia/testing'
 import { HttpResponse, http } from 'msw'
 import { createPinia, setActivePinia } from 'pinia'
-import { createApp } from 'vue'
-import { createStore } from 'vuex'
 
 import {
   authApis,
@@ -9,203 +8,191 @@ import {
   testServer,
 } from '/test/fixtures/mock_api.js'
 
+import { useInstanceStore } from 'src/stores/instance.js'
 import { useOAuthStore } from 'src/stores/oauth.js'
 
 const test = injectMswToTest(authApis)
 
-const vuexStore = createStore({
-  modules: {
-    instance: {
-      state: () => ({ server: testServer }),
-    },
-  },
-})
-const app = createApp({})
-app.use(vuexStore)
-window.vuex = vuexStore
-
-const getStore = (defaultStateInjection) => {
-  const pinia = createPinia().use(({ store }) => {
-    if (store.$id === 'oauth') {
-      store.$patch(defaultStateInjection)
-    }
-  })
-  app.use(pinia)
-  setActivePinia(pinia)
-  return useOAuthStore()
-}
-
-describe('createApp', () => {
-  test('it should use create an app and record client id and secret', async () => {
-    const store = getStore()
-    const app = await store.createApp()
-    expect(store.clientId).to.eql('test-id')
-    expect(store.clientSecret).to.eql('test-secret')
-    expect(app.clientId).to.eql('test-id')
-    expect(app.clientSecret).to.eql('test-secret')
+describe('oauth store', () => {
+  beforeEach(() => {
+    setActivePinia(createTestingPinia({ stubActions: false }))
+    useInstanceStore().server = testServer
   })
 
-  test('it should throw and not update if failed', async ({ worker }) => {
-    worker.use(
-      http.post(`${testServer}/api/v1/apps`, () => {
-        return HttpResponse.text('Throttled', { status: 429 })
-      }),
-    )
+  describe('createApp', () => {
+    test('it should use create an app and record client id and secret', async () => {
+      const store = useOAuthStore()
+      const app = await store.createApp()
+      expect(store.clientId).to.eql('test-id')
+      expect(store.clientSecret).to.eql('test-secret')
+      expect(app.clientId).to.eql('test-id')
+      expect(app.clientSecret).to.eql('test-secret')
+    })
 
-    const store = getStore()
-    const res = store.createApp()
-    await expect(res).rejects.toThrowError('Throttled')
-    expect(store.clientId).to.eql(false)
-    expect(store.clientSecret).to.eql(false)
-  })
-})
-
-describe('ensureApp', () => {
-  test('it should create an app if it does not exist', async () => {
-    const store = getStore()
-    const app = await store.ensureApp()
-    expect(store.clientId).to.eql('test-id')
-    expect(store.clientSecret).to.eql('test-secret')
-    expect(app.clientId).to.eql('test-id')
-    expect(app.clientSecret).to.eql('test-secret')
-  })
-
-  test('it should not create an app if it exists', async ({ worker }) => {
-    worker.use(
-      http.post(`${testServer}/api/v1/apps`, () => {
-        return HttpResponse.text('Should not call this API', { status: 400 })
-      }),
-    )
-
-    const store = getStore({
-      clientId: 'another-id',
-      clientSecret: 'another-secret',
-    })
-    const app = await store.ensureApp()
-    expect(store.clientId).to.eql('another-id')
-    expect(store.clientSecret).to.eql('another-secret')
-    expect(app.clientId).to.eql('another-id')
-    expect(app.clientSecret).to.eql('another-secret')
-  })
-})
-
-describe('getAppToken', () => {
-  test('it should get app token and set it in state', async () => {
-    const store = getStore({
-      clientId: 'test-id',
-      clientSecret: 'test-secret',
-    })
-    const token = await store.getAppToken()
-    expect(token).to.eql('test-app-token')
-    expect(store.appToken).to.eql('test-app-token')
-  })
-
-  test('it should throw and not set state if it cannot get app token', async () => {
-    const store = getStore({
-      clientId: 'bad-id',
-      clientSecret: 'bad-secret',
-    })
-    await expect(store.getAppToken()).rejects.toThrowError('400')
-    expect(store.appToken).to.eql(false)
-  })
-})
-
-describe('ensureAppToken', () => {
-  test('it should work if the state is empty', async () => {
-    const store = getStore()
-    const token = await store.ensureAppToken()
-    expect(token).to.eql('test-app-token')
-    expect(store.appToken).to.eql('test-app-token')
-  })
-
-  test('it should work if we already have a working token', async () => {
-    const store = getStore({
-      appToken: 'also-good-app-token',
-    })
-    const token = await store.ensureAppToken()
-    expect(token).to.eql('also-good-app-token')
-    expect(store.appToken).to.eql('also-good-app-token')
-  })
-
-  test('it should work if we have a bad token but good app credentials', async ({
-    worker,
-  }) => {
-    worker.use(
-      http.post(`${testServer}/api/v1/apps`, () => {
-        return HttpResponse.text('Should not call this API', { status: 400 })
-      }),
-    )
-    const store = getStore({
-      appToken: 'bad-app-token',
-      clientId: 'test-id',
-      clientSecret: 'test-secret',
-    })
-    const token = await store.ensureAppToken()
-    expect(token).to.eql('test-app-token')
-    expect(store.appToken).to.eql('test-app-token')
-  })
-
-  test('it should work if we have no token but good app credentials', async ({
-    worker,
-  }) => {
-    worker.use(
-      http.post(`${testServer}/api/v1/apps`, () => {
-        return HttpResponse.text('Should not call this API', { status: 400 })
-      }),
-    )
-    const store = getStore({
-      clientId: 'test-id',
-      clientSecret: 'test-secret',
-    })
-    const token = await store.ensureAppToken()
-    expect(token).to.eql('test-app-token')
-    expect(store.appToken).to.eql('test-app-token')
-  })
-
-  test('it should work if we have no token and bad app credentials', async () => {
-    const store = getStore({
-      clientId: 'bad-id',
-      clientSecret: 'bad-secret',
-    })
-    const token = await store.ensureAppToken()
-    expect(token).to.eql('test-app-token')
-    expect(store.appToken).to.eql('test-app-token')
-    expect(store.clientId).to.eql('test-id')
-    expect(store.clientSecret).to.eql('test-secret')
-  })
-
-  test('it should work if we have bad token and bad app credentials', async () => {
-    const store = getStore({
-      appToken: 'bad-app-token',
-      clientId: 'bad-id',
-      clientSecret: 'bad-secret',
-    })
-    const token = await store.ensureAppToken()
-    expect(token).to.eql('test-app-token')
-    expect(store.appToken).to.eql('test-app-token')
-    expect(store.clientId).to.eql('test-id')
-    expect(store.clientSecret).to.eql('test-secret')
-  })
-
-  test('it should throw if we cannot create an app', async ({ worker }) => {
-    worker.use(
-      http.post(`${testServer}/api/v1/apps`, () => {
-        return HttpResponse.text('Throttled', { status: 429 })
-      }),
-    )
-
-    const store = getStore()
-    await expect(store.ensureAppToken()).rejects.toThrowError('Throttled')
-  })
-
-  test('it should throw if we cannot obtain app token', async ({ worker }) => {
-    worker.use(
-      http.post(`${testServer}/oauth/token`, () => {
-        return HttpResponse.text('Throttled', { status: 429 })
-      }),
-    )
-
-    const store = getStore()
-    await expect(store.ensureAppToken()).rejects.toThrowError('Throttled')
+    test('it should throw and not update if failed', async ({ worker }) => {
+      worker.use(
+        http.post(`${testServer}/api/v1/apps`, () => {
+          return HttpResponse.text('Throttled', { status: 429 })
+        }),
+      )
+
+      const store = useOAuthStore()
+      const res = store.createApp()
+      await expect(res).rejects.toThrowError('Throttled')
+      expect(store.clientId).to.eql(false)
+      expect(store.clientSecret).to.eql(false)
+    })
+  })
+
+  describe('ensureApp', () => {
+    test('it should create an app if it does not exist', async () => {
+      const store = useOAuthStore()
+      const app = await store.ensureApp()
+      expect(store.clientId).to.eql('test-id')
+      expect(store.clientSecret).to.eql('test-secret')
+      expect(app.clientId).to.eql('test-id')
+      expect(app.clientSecret).to.eql('test-secret')
+    })
+
+    test('it should not create an app if it exists', async ({ worker }) => {
+      worker.use(
+        http.post(`${testServer}/api/v1/apps`, () => {
+          return HttpResponse.text('Should not call this API', { status: 400 })
+        }),
+      )
+
+      const store = useOAuthStore()
+      store.clientId = 'another-id'
+      store.clientSecret = 'another-secret'
+
+      const app = await store.ensureApp()
+      expect(store.clientId).to.eql('another-id')
+      expect(store.clientSecret).to.eql('another-secret')
+      expect(app.clientId).to.eql('another-id')
+      expect(app.clientSecret).to.eql('another-secret')
+    })
+  })
+
+  describe('getAppToken', () => {
+    test('it should get app token and set it in state', async () => {
+      const store = useOAuthStore()
+      store.clientId = 'test-id'
+      store.clientSecret = 'test-secret'
+
+      const token = await store.getAppToken()
+      expect(token).to.eql('test-app-token')
+      expect(store.appToken).to.eql('test-app-token')
+    })
+
+    test('it should throw and not set state if it cannot get app token', async () => {
+      const store = useOAuthStore()
+      store.clientId = 'bad-id'
+      store.clientSecret = 'bad-secret'
+
+      await expect(store.getAppToken()).rejects.toThrowError('400')
+      expect(store.appToken).to.eql(false)
+    })
+  })
+
+  describe('ensureAppToken', () => {
+    test('it should work if the state is empty', async () => {
+      const store = useOAuthStore()
+      const token = await store.ensureAppToken()
+      expect(token).to.eql('test-app-token')
+      expect(store.appToken).to.eql('test-app-token')
+    })
+
+    test('it should work if we already have a working token', async () => {
+      const store = useOAuthStore()
+      store.appToken = 'also-good-app-token'
+
+      const token = await store.ensureAppToken()
+      expect(token).to.eql('also-good-app-token')
+      expect(store.appToken).to.eql('also-good-app-token')
+    })
+
+    test('it should work if we have a bad token but good app credentials', async ({
+      worker,
+    }) => {
+      worker.use(
+        http.post(`${testServer}/api/v1/apps`, () => {
+          return HttpResponse.text('Should not call this API', { status: 400 })
+        }),
+      )
+      const store = useOAuthStore()
+      store.appToken = 'bad-app-token'
+      store.clientId = 'test-id'
+      store.clientSecret = 'test-secret'
+
+      const token = await store.ensureAppToken()
+      expect(token).to.eql('test-app-token')
+      expect(store.appToken).to.eql('test-app-token')
+    })
+
+    test('it should work if we have no token but good app credentials', async ({
+      worker,
+    }) => {
+      worker.use(
+        http.post(`${testServer}/api/v1/apps`, () => {
+          return HttpResponse.text('Should not call this API', { status: 400 })
+        }),
+      )
+      const store = useOAuthStore()
+      store.clientId = 'test-id'
+      store.clientSecret = 'test-secret'
+
+      const token = await store.ensureAppToken()
+      expect(token).to.eql('test-app-token')
+      expect(store.appToken).to.eql('test-app-token')
+    })
+
+    test('it should work if we have no token and bad app credentials', async () => {
+      const store = useOAuthStore()
+      store.clientId = 'bad-id'
+      store.clientSecret = 'bad-secret'
+
+      const token = await store.ensureAppToken()
+      expect(token).to.eql('test-app-token')
+      expect(store.appToken).to.eql('test-app-token')
+      expect(store.clientId).to.eql('test-id')
+      expect(store.clientSecret).to.eql('test-secret')
+    })
+
+    test('it should work if we have bad token and bad app credentials', async () => {
+      const store = useOAuthStore()
+      store.appToken = 'bad-app-token'
+      store.clientId = 'bad-id'
+      store.clientSecret = 'bad-secret'
+
+      const token = await store.ensureAppToken()
+      expect(token).to.eql('test-app-token')
+      expect(store.appToken).to.eql('test-app-token')
+      expect(store.clientId).to.eql('test-id')
+      expect(store.clientSecret).to.eql('test-secret')
+    })
+
+    test('it should throw if we cannot create an app', async ({ worker }) => {
+      worker.use(
+        http.post(`${testServer}/api/v1/apps`, () => {
+          return HttpResponse.text('Throttled', { status: 429 })
+        }),
+      )
+
+      const store = useOAuthStore()
+      await expect(store.ensureAppToken()).rejects.toThrowError('Throttled')
+    })
+
+    test('it should throw if we cannot obtain app token', async ({
+      worker,
+    }) => {
+      worker.use(
+        http.post(`${testServer}/oauth/token`, () => {
+          return HttpResponse.text('Throttled', { status: 429 })
+        }),
+      )
+
+      const store = useOAuthStore()
+      await expect(store.ensureAppToken()).rejects.toThrowError('Throttled')
+    })
   })
 })