No OneTemporary
Actions

Size

36 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/unit/specs/boot/routes.spec.js b/test/unit/specs/boot/routes.spec.js
	index 8795ea04eb..f4be28a65d 100644
	--- a/test/unit/specs/boot/routes.spec.js
	+++ b/test/unit/specs/boot/routes.spec.js
	@@ -1,97 +1,99 @@
	import { createTestingPinia } from '@pinia/testing'
	- createTestingPinia()
	+
	+createTestingPinia()
	+
	import { createMemoryHistory, createRouter } from 'vue-router'
	import { createStore } from 'vuex'

	import routes from 'src/boot/routes'

	const store = createStore({
	state: {
	instance: {},
	},
	})

	describe('routes', () => {
	const router = createRouter({
	history: createMemoryHistory(),
	routes: routes(store),
	})

	it('root path', async () => {
	await router.push('/main/all')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'Timeline',
	),
	).to.eql(true)
	})

	it("user's profile", async () => {
	await router.push('/fake-user-name')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'UserCard',
	),
	).to.eql(true)
	})

	it("user's profile at /users", async () => {
	await router.push('/users/fake-user-name')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'UserCard',
	),
	).to.eql(true)
	})

	it('list view', async () => {
	await router.push('/lists')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'ListsCard',
	),
	).to.eql(true)
	})

	it('list timeline', async () => {
	await router.push('/lists/1')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'Timeline',
	),
	).to.eql(true)
	})

	it('list edit', async () => {
	await router.push('/lists/1/edit')

	const matchedComponents = router.currentRoute.value.matched

	expect(
	Object.hasOwn(
	matchedComponents[0].components.default.components,
	'BasicUserCard',
	),
	).to.eql(true)
	})
	})
	diff --git a/test/unit/specs/components/draft.spec.js b/test/unit/specs/components/draft.spec.js
	index eb35cb58f3..7bc053f524 100644
	--- a/test/unit/specs/components/draft.spec.js
	+++ b/test/unit/specs/components/draft.spec.js
	@@ -1,184 +1,184 @@
	+import { createTestingPinia } from '@pinia/testing'
	import { flushPromises, mount } from '@vue/test-utils'
	import { nextTick } from 'vue'
	-import { createTestingPinia } from '@pinia/testing'

	import PostStatusForm from 'src/components/post_status_form/post_status_form.vue'
	import { $t, mountOpts, waitForEvent } from '../../../fixtures/setup_test'

	const autoSaveOrNot = (caseFn, caseTitle, runFn) => {
	caseFn(`${caseTitle} with auto-save`, function () {
	return runFn.bind(this)(true)
	})

	caseFn(`${caseTitle} with no auto-save`, function () {
	return runFn.bind(this)(false)
	})
	}

	const saveManually = async (wrapper) => {
	const morePostActions = wrapper.findByText(
	'button',
	$t('post_status.more_post_actions'),
	)
	await morePostActions.trigger('click')

	const btn = wrapper.findByText(
	'button',
	$t('post_status.save_to_drafts_button'),
	)
	await btn.trigger('click')
	}

	const waitSaveTime = 4000

	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')
	await textarea.setValue('mew mew')

	await saveManually(wrapper)
	expect(wrapper.vm.$store.getters.draftCount).to.equal(1)
	expect(wrapper.vm.$store.getters.draftsArray[0].status).to.equal(
	'mew mew',
	)
	},
	)

	it('should auto-save if it is enabled', async function () {
	vi.useFakeTimers()
	const wrapper = mount(PostStatusForm, mountOpts())
	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')

	expect(wrapper.vm.$store.getters.draftCount).to.equal(0)
	await vi.advanceTimersByTimeAsync(waitSaveTime)
	expect(wrapper.vm.$store.getters.draftCount).to.equal(1)
	expect(wrapper.vm.$store.getters.draftsArray[0].status).to.equal('mew mew')
	})

	it('should auto-save when close if auto-save is on', async () => {
	const wrapper = mount(
	PostStatusForm,
	mountOpts({
	props: {
	closeable: true,
	},
	}),
	)
	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')
	wrapper.vm.requestClose()
	expect(wrapper.vm.$store.getters.draftCount).to.equal(1)
	await waitForEvent(wrapper, 'can-close')
	})

	it('should save when close if auto-save is off, and unsavedPostAction is save', async () => {
	const wrapper = mount(
	PostStatusForm,
	mountOpts({
	props: {
	closeable: true,
	},
	}),
	)
	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')
	wrapper.vm.requestClose()
	expect(wrapper.vm.$store.getters.draftCount).to.equal(1)
	await waitForEvent(wrapper, 'can-close')
	})

	it('should discard when close if auto-save is off, and unsavedPostAction is discard', async () => {
	const wrapper = mount(
	PostStatusForm,
	mountOpts({
	props: {
	closeable: true,
	},
	}),
	)
	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')
	wrapper.vm.requestClose()
	await waitForEvent(wrapper, 'can-close')
	expect(wrapper.vm.$store.getters.draftCount).to.equal(0)
	})

	it('should confirm when close if auto-save is off, and unsavedPostAction is confirm', async () => {
	const wrapper = mount(
	PostStatusForm,
	mountOpts({
	props: {
	closeable: true,
	},
	}),
	)
	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')
	wrapper.vm.requestClose()
	await nextTick()
	const saveButton = wrapper.findByText(
	'button',
	$t('post_status.close_confirm_save_button'),
	)
	expect(saveButton).to.be.ok
	await saveButton.trigger('click')
	console.info('clicked')
	expect(wrapper.vm.$store.getters.draftCount).to.equal(1)
	await flushPromises()
	await waitForEvent(wrapper, 'can-close')
	})
	})
	diff --git a/test/unit/specs/components/emoji_input.spec.js b/test/unit/specs/components/emoji_input.spec.js
	index 83ffd13d2b..032e7e9b6d 100644
	--- a/test/unit/specs/components/emoji_input.spec.js
	+++ b/test/unit/specs/components/emoji_input.spec.js
	@@ -1,157 +1,158 @@
	+import { createTestingPinia } from '@pinia/testing'
	import { shallowMount } from '@vue/test-utils'
	import vClickOutside from 'click-outside-vue3'
	import { h } from 'vue'
	-import { createTestingPinia } from '@pinia/testing'
	- createTestingPinia()
	+
	+createTestingPinia()

	import EmojiInput from 'src/components/emoji_input/emoji_input.vue'

	const generateInput = (value, padEmoji = true) => {
	const wrapper = shallowMount(EmojiInput, {
	global: {
	renderStubDefaultSlot: true,
	mocks: {
	$store: {
	getters: {
	mergedConfig: {
	padEmoji,
	},
	},
	},
	$t: (msg) => msg,
	},
	stubs: {
	FAIcon: true,
	Popover: {
	template: `<div><slot trigger /></div>`,
	methods: {
	updateStyles() {
	/* no-op */
	},
	},
	},
	},
	directives: {
	'click-outside': vClickOutside,
	},
	},
	props: {
	suggest: () => [],
	enableEmojiPicker: true,
	modelValue: value,
	},
	slots: {
	default: () => h('input', ''),
	},
	})
	return wrapper
	}

	describe('EmojiInput', () => {
	describe('insertion mechanism', () => {
	it('inserts string at the end with trailing space', () => {
	const initialString = 'Testing'
	const wrapper = generateInput(initialString)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: initialString.length })
	wrapper.vm.insert({ insertion: '(test)', keepOpen: false })
	const inputEvents = wrapper.emitted()['update:modelValue']
	expect(inputEvents[inputEvents.length - 1][0]).to.eql('Testing (test) ')
	})

	it('inserts string at the end with trailing space (source has a trailing space)', () => {
	const initialString = 'Testing '
	const wrapper = generateInput(initialString)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: initialString.length })
	wrapper.vm.insert({ insertion: '(test)', keepOpen: false })
	const inputEvents = wrapper.emitted()['update:modelValue']
	expect(inputEvents[inputEvents.length - 1][0]).to.eql('Testing (test) ')
	})

	it('inserts string at the begginning without leading space', () => {
	const initialString = 'Testing'
	const wrapper = generateInput(initialString)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: 0 })
	wrapper.vm.insert({ insertion: '(test)', keepOpen: false })
	const inputEvents = wrapper.emitted()['update:modelValue']
	expect(inputEvents[inputEvents.length - 1][0]).to.eql('(test) Testing')
	})

	it('inserts string between words without creating extra spaces', () => {
	const initialString = 'Spurdo Sparde'
	const wrapper = generateInput(initialString)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: 6 })
	wrapper.vm.insert({ insertion: ':ebin:', keepOpen: false })
	const inputEvents = wrapper.emitted()['update:modelValue']
	expect(inputEvents[inputEvents.length - 1][0]).to.eql(
	'Spurdo :ebin: Sparde',
	)
	})

	it('inserts string between words without creating extra spaces (other caret)', () => {
	const initialString = 'Spurdo Sparde'
	const wrapper = generateInput(initialString)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: 7 })
	wrapper.vm.insert({ insertion: ':ebin:', keepOpen: false })
	const inputEvents = wrapper.emitted()['update:modelValue']
	expect(inputEvents[inputEvents.length - 1][0]).to.eql(
	'Spurdo :ebin: Sparde',
	)
	})

	it('inserts string without any padding if padEmoji setting is set to false', () => {
	const initialString = 'Eat some spam!'
	const wrapper = generateInput(initialString, false)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: initialString.length, keepOpen: false })
	wrapper.vm.insert({ insertion: ':spam:' })
	const inputEvents = wrapper.emitted()['update:modelValue']
	expect(inputEvents[inputEvents.length - 1][0]).to.eql(
	'Eat some spam!:spam:',
	)
	})

	it('correctly sets caret after insertion at beginning', async () => {
	const initialString = '1234'
	const wrapper = generateInput(initialString)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: 0 })
	wrapper.vm.insert({ insertion: '1234', keepOpen: false })
	await wrapper.vm.$nextTick()
	expect(wrapper.vm.caret).to.eql(5)
	})

	it('correctly sets caret after insertion at end', async () => {
	const initialString = '1234'
	const wrapper = generateInput(initialString)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: initialString.length })
	wrapper.vm.insert({ insertion: '1234', keepOpen: false })
	await wrapper.vm.$nextTick()
	expect(wrapper.vm.caret).to.eql(10)
	})

	it('correctly sets caret after insertion if padEmoji setting is set to false', async () => {
	const initialString = '1234'
	const wrapper = generateInput(initialString, false)
	const input = wrapper.find('input')
	input.setValue(initialString)
	wrapper.setData({ caret: initialString.length })
	wrapper.vm.insert({ insertion: '1234', keepOpen: false })
	await wrapper.vm.$nextTick()
	expect(wrapper.vm.caret).to.eql(8)
	})
	})
	})
	diff --git a/test/unit/specs/modules/statuses.spec.js b/test/unit/specs/modules/statuses.spec.js
	index 3d1027ad4b..1315724daa 100644
	--- a/test/unit/specs/modules/statuses.spec.js
	+++ b/test/unit/specs/modules/statuses.spec.js
	@@ -1,445 +1,447 @@
	+import { createTestingPinia } from '@pinia/testing'
	+
	import {
	defaultState,
	mutations,
	prepareStatus,
	} from '../../../../src/modules/statuses.js'
	-import { createTestingPinia } from '@pinia/testing'
	- createTestingPinia()
	+
	+createTestingPinia()

	const makeMockStatus = ({ id, text, type = 'status' }) => {
	return {
	id,
	user: { id: '0' },
	name: 'status',
	text: text \|\| `Text number ${id}`,
	fave_num: 0,
	uri: '',
	type,
	attentions: [],
	}
	}

	describe('Statuses module', () => {
	describe('prepareStatus', () => {
	it('sets deleted flag to false', () => {
	const aStatus = makeMockStatus({ id: '1', text: 'Hello oniichan' })
	expect(prepareStatus(aStatus).deleted).to.eq(false)
	})
	})

	describe('addNewStatuses', () => {
	it('adds the status to allStatuses and to the given timeline', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })

	mutations.addNewStatuses(state, {
	statuses: [status],
	timeline: 'public',
	})

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([status])
	expect(state.timelines.public.visibleStatuses).to.eql([])
	expect(state.timelines.public.newStatusCount).to.equal(1)
	})

	it('counts the status as new if it has not been seen on this timeline', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })

	mutations.addNewStatuses(state, {
	statuses: [status],
	timeline: 'public',
	})
	mutations.addNewStatuses(state, {
	statuses: [status],
	timeline: 'friends',
	})

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([status])
	expect(state.timelines.public.visibleStatuses).to.eql([])
	expect(state.timelines.public.newStatusCount).to.equal(1)

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.friends.statuses).to.eql([status])
	expect(state.timelines.friends.visibleStatuses).to.eql([])
	expect(state.timelines.friends.newStatusCount).to.equal(1)
	})

	it('add the statuses to allStatuses if no timeline is given', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })

	mutations.addNewStatuses(state, { statuses: [status] })

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([])
	expect(state.timelines.public.visibleStatuses).to.eql([])
	expect(state.timelines.public.newStatusCount).to.equal(0)
	})

	it('adds the status to allStatuses and to the given timeline, directly visible', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})

	expect(state.allStatuses).to.eql([status])
	expect(state.timelines.public.statuses).to.eql([status])
	expect(state.timelines.public.visibleStatuses).to.eql([status])
	expect(state.timelines.public.newStatusCount).to.equal(0)
	})

	it('does not update the maxId when the noIdUpdate flag is set', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	const secondStatus = makeMockStatus({ id: '2' })

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	expect(state.timelines.public.maxId).to.eql('1')

	mutations.addNewStatuses(state, {
	statuses: [secondStatus],
	showImmediately: true,
	timeline: 'public',
	noIdUpdate: true,
	})
	expect(state.timelines.public.statuses).to.eql([secondStatus, status])
	expect(state.timelines.public.visibleStatuses).to.eql([
	secondStatus,
	status,
	])
	expect(state.timelines.public.maxId).to.eql('1')
	})

	it('keeps a descending by id order in timeline.visibleStatuses and timeline.statuses', () => {
	const state = defaultState()
	const nonVisibleStatus = makeMockStatus({ id: '1' })
	const status = makeMockStatus({ id: '3' })
	const statusTwo = makeMockStatus({ id: '2' })
	const statusThree = makeMockStatus({ id: '4' })

	mutations.addNewStatuses(state, {
	statuses: [nonVisibleStatus],
	showImmediately: false,
	timeline: 'public',
	})

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	mutations.addNewStatuses(state, {
	statuses: [statusTwo],
	showImmediately: true,
	timeline: 'public',
	})

	expect(state.timelines.public.minVisibleId).to.equal('2')

	mutations.addNewStatuses(state, {
	statuses: [statusThree],
	showImmediately: true,
	timeline: 'public',
	})

	expect(state.timelines.public.statuses).to.eql([
	statusThree,
	status,
	statusTwo,
	nonVisibleStatus,
	])
	expect(state.timelines.public.visibleStatuses).to.eql([
	statusThree,
	status,
	statusTwo,
	])
	})

	it('splits retweets from their status and links them', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	const retweet = makeMockStatus({ id: '2', type: 'retweet' })
	const modStatus = makeMockStatus({ id: '1', text: 'something else' })

	retweet.retweeted_status = status

	// It adds both statuses, but only the retweet to visible.
	mutations.addNewStatuses(state, {
	statuses: [retweet],
	timeline: 'public',
	showImmediately: true,
	})
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.timelines.public.statuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(2)
	expect(state.allStatuses[0].id).to.equal('1')
	expect(state.allStatuses[1].id).to.equal('2')

	// It refers to the modified status.
	mutations.addNewStatuses(state, {
	statuses: [modStatus],
	timeline: 'public',
	})
	expect(state.allStatuses).to.have.length(2)
	expect(state.allStatuses[0].id).to.equal('1')
	expect(state.allStatuses[0].text).to.equal(modStatus.text)
	expect(state.allStatuses[1].id).to.equal('2')
	expect(retweet.retweeted_status.text).to.eql(modStatus.text)
	})

	it('replaces existing statuses with the same id', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	const modStatus = makeMockStatus({ id: '1', text: 'something else' })

	// Add original status
	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(1)

	// Add new version of status
	mutations.addNewStatuses(state, {
	statuses: [modStatus],
	showImmediately: true,
	timeline: 'public',
	})
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(1)
	expect(state.allStatuses[0].text).to.eql(modStatus.text)
	})

	it('replaces existing statuses with the same id, coming from a retweet', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	const modStatus = makeMockStatus({ id: '1', text: 'something else' })
	const retweet = makeMockStatus({ id: '2', type: 'retweet' })
	retweet.retweeted_status = modStatus

	// Add original status
	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(1)

	// Add new version of status
	mutations.addNewStatuses(state, {
	statuses: [retweet],
	showImmediately: false,
	timeline: 'public',
	})
	expect(state.timelines.public.visibleStatuses).to.have.length(1)
	// Don't add the retweet itself if the tweet is visible
	expect(state.timelines.public.statuses).to.have.length(1)
	expect(state.allStatuses).to.have.length(2)
	expect(state.allStatuses[0].text).to.eql(modStatus.text)
	})

	it('handles favorite actions', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })

	const favorite = {
	id: '2',
	type: 'favorite',
	in_reply_to_status_id: '1', // The API uses strings here...
	uri: 'tag:shitposter.club,2016-08-21:fave:3895:note:773501:2016-08-21T16:52:15+00:00',
	text: 'a favorited something by b',
	user: { id: '99' },
	}

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	mutations.addNewStatuses(state, {
	statuses: [favorite],
	showImmediately: true,
	timeline: 'public',
	})

	expect(state.timelines.public.visibleStatuses.length).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].fave_num).to.eql(1)
	expect(state.timelines.public.maxId).to.eq(favorite.id)

	// Adding it again does nothing
	mutations.addNewStatuses(state, {
	statuses: [favorite],
	showImmediately: true,
	timeline: 'public',
	})

	expect(state.timelines.public.visibleStatuses.length).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].fave_num).to.eql(1)
	expect(state.timelines.public.maxId).to.eq(favorite.id)

	// If something is favorited by the current user, it also sets the 'favorited' property but does not increment counter to avoid over-counting. Counter is incremented (updated, really) via response to the favorite request.
	const user = {
	id: '1',
	}

	const ownFavorite = {
	id: '3',
	type: 'favorite',
	in_reply_to_status_id: '1', // The API uses strings here...
	uri: 'tag:shitposter.club,2016-08-21:fave:3895:note:773501:2016-08-21T16:52:15+00:00',
	text: 'a favorited something by b',
	user,
	}

	mutations.addNewStatuses(state, {
	statuses: [ownFavorite],
	showImmediately: true,
	timeline: 'public',
	user,
	})

	expect(state.timelines.public.visibleStatuses.length).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].fave_num).to.eql(1)
	expect(state.timelines.public.visibleStatuses[0].favorited).to.eql(true)
	})
	})

	describe('emojiReactions', () => {
	it('increments count in existing reaction', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	status.emoji_reactions = [{ name: '😂', count: 1, accounts: [] }]

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	mutations.addOwnReaction(state, {
	id: '1',
	emoji: '😂',
	currentUser: { id: 'me' },
	})
	expect(state.allStatusesObject['1'].emoji_reactions[0].count).to.eql(2)
	expect(state.allStatusesObject['1'].emoji_reactions[0].me).to.eql(true)
	expect(
	state.allStatusesObject['1'].emoji_reactions[0].accounts[0].id,
	).to.eql('me')
	})

	it('adds a new reaction', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	status.emoji_reactions = []

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	mutations.addOwnReaction(state, {
	id: '1',
	emoji: '😂',
	currentUser: { id: 'me' },
	})
	expect(state.allStatusesObject['1'].emoji_reactions[0].count).to.eql(1)
	expect(state.allStatusesObject['1'].emoji_reactions[0].me).to.eql(true)
	expect(
	state.allStatusesObject['1'].emoji_reactions[0].accounts[0].id,
	).to.eql('me')
	})

	it('decreases count in existing reaction', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	status.emoji_reactions = [
	{ name: '😂', count: 2, accounts: [{ id: 'me' }] },
	]

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	mutations.removeOwnReaction(state, {
	id: '1',
	emoji: '😂',
	currentUser: { id: 'me' },
	})
	expect(state.allStatusesObject['1'].emoji_reactions[0].count).to.eql(1)
	expect(state.allStatusesObject['1'].emoji_reactions[0].me).to.eql(false)
	expect(state.allStatusesObject['1'].emoji_reactions[0].accounts).to.eql(
	[],
	)
	})

	it('removes a reaction', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '1' })
	status.emoji_reactions = [
	{ name: '😂', count: 1, accounts: [{ id: 'me' }] },
	]

	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	mutations.removeOwnReaction(state, {
	id: '1',
	emoji: '😂',
	currentUser: { id: 'me' },
	})
	expect(state.allStatusesObject['1'].emoji_reactions.length).to.eql(0)
	})
	})

	describe('showNewStatuses', () => {
	it('resets the minId to the min of the visible statuses when adding new to visible statuses', () => {
	const state = defaultState()
	const status = makeMockStatus({ id: '10' })
	mutations.addNewStatuses(state, {
	statuses: [status],
	showImmediately: true,
	timeline: 'public',
	})
	const newStatus = makeMockStatus({ id: '20' })
	mutations.addNewStatuses(state, {
	statuses: [newStatus],
	showImmediately: false,
	timeline: 'public',
	})
	state.timelines.public.minId = '5'
	mutations.showNewStatuses(state, { timeline: 'public' })

	expect(state.timelines.public.visibleStatuses.length).to.eql(2)
	expect(state.timelines.public.minVisibleId).to.eql('10')
	expect(state.timelines.public.minId).to.eql('10')
	})
	})

	describe('clearTimeline', () => {
	it('keeps userId when clearing user timeline when excludeUserId param is true', () => {
	const state = defaultState()
	state.timelines.user.userId = 123

	mutations.clearTimeline(state, { timeline: 'user', excludeUserId: true })

	expect(state.timelines.user.userId).to.eql(123)
	})
	})
	})
	diff --git a/test/unit/specs/stores/oauth.spec.js b/test/unit/specs/stores/oauth.spec.js
	index 977b154328..4664bba027 100644
	--- a/test/unit/specs/stores/oauth.spec.js
	+++ b/test/unit/specs/stores/oauth.spec.js
	@@ -1,197 +1,198 @@
	-import { HttpResponse, http } from 'msw'
	-import { setActivePinia, createPinia } from 'pinia'
	import { createTestingPinia } from '@pinia/testing'
	+import { HttpResponse, http } from 'msw'
	+import { createPinia, setActivePinia } from 'pinia'

	import {
	authApis,
	injectMswToTest,
	testServer,
	} from '/test/fixtures/mock_api.js'

	-import { useOAuthStore } from 'src/stores/oauth.js'
	import { useInstanceStore } from 'src/stores/instance.js'
	+import { useOAuthStore } from 'src/stores/oauth.js'

	const test = injectMswToTest(authApis)

	describe('oauth store', () => {
	beforeEach(() => {
	setActivePinia(createTestingPinia({ stubActions: false }))
	useInstanceStore().server = testServer
	})

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

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

File Metadata

Mime Type: text/x-diff
Expires: Sun, Aug 30, 8:30 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1737868
Default Alt Text: (36 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions