No OneTemporary
Actions

Size

50 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/test/unit/specs/components/chat_view.spec.js b/test/unit/specs/components/chat_view.spec.js
	index c308e4fbc3..d03809e387 100644
	--- a/test/unit/specs/components/chat_view.spec.js
	+++ b/test/unit/specs/components/chat_view.spec.js
	@@ -1,137 +1,137 @@
	import { createTestingPinia } from '@pinia/testing'
	import { shallowMount } from '@vue/test-utils'
	import { setActivePinia } from 'pinia'

	import ChatView from 'src/components/chat_view/chat_view.vue'

	const message1 = {
	id: '1',
	chat_id: 2,
	idempotency_key: '1',
	created_at: new Date('2020-06-22T18:45:53.000Z'),
	}

	const message2 = {
	id: '2',
	chat_id: 2,
	idempotency_key: '2',
	account_id: '9vmRb29zLQReckr5ay',
	created_at: new Date('2020-06-22T18:45:56.000Z'),
	}

	const message3 = {
	id: '3',
	chat_id: 2,
	idempotency_key: '3',
	account_id: '9vmRb29zLQReckr5ay',
	created_at: new Date('2020-07-22T18:45:59.000Z'),
	}

	const global = {
	mocks: {
	$store: {
	state: {
	api: {},
	users: {},
	statuses: {
	allStatusesObject: {},
	},
	},
	},
	$route: {
	params: {
	recipient_id: 2,
	},
	},
	$router: {
	push: () => {
	/* noop */
	},
	},
	},
	stubs: {
	FAIcon: true,
	},
	}

	describe('ChatView methods', () => {
	let component
	beforeEach(() => {
	setActivePinia(createTestingPinia())
	component = shallowMount(ChatView, { global, props: { testMode: true } })
	component.vm.chat = { id: 2 }
	})

	describe('addMessages', () => {
	it("Doesn't add duplicates", () => {
	component.vm.addMessages({ messages: [message1] })
	component.vm.addMessages({ messages: [message1] })
	- expect(component.vm.messages.length).to.eql(1)
	+ expect(component.vm.messages).to.have.length(1)

	component.vm.addMessages({ messages: [message2] })
	- expect(component.vm.messages.length).to.eql(2)
	+ expect(component.vm.messages).to.have.length(2)
	})

	it('Updates minId and lastMessage and newMessageCount', async () => {
	component.vm.addMessages({ messages: [message1] })
	expect(component.vm.maxId).to.eql(message1.id)
	expect(component.vm.minId).to.eql(message1.id)
	expect(component.vm.newMessageCount).to.eql(1)

	component.vm.addMessages({ messages: [message2] })
	expect(component.vm.maxId).to.eql(message2.id)
	expect(component.vm.minId).to.eql(message1.id)
	expect(component.vm.newMessageCount).to.eql(2)

	await component.vm.readChat()
	expect(component.vm.newMessageCount).to.eql(0)
	expect(component.vm.lastReadMessageId).to.eql(message2.id)

	// Add message with higher id
	component.vm.addMessages({ messages: [message3] })
	expect(component.vm.newMessageCount).to.eql(1)
	})
	})

	describe('deleteChatMessage', () => {
	it('Updates minId and lastMessage', () => {
	component.vm.addMessages({ messages: [message1] })
	component.vm.addMessages({ messages: [message2] })
	component.vm.addMessages({ messages: [message3] })

	expect(component.vm.maxId).to.eql(message3.id)
	expect(component.vm.minId).to.eql(message1.id)

	component.vm.deleteChatMessage({ messageId: message3.id })
	expect(component.vm.maxId).to.eql(message2.id)
	expect(component.vm.minId).to.eql(message1.id)

	component.vm.deleteChatMessage({ messageId: message1.id })
	expect(component.vm.maxId).to.eql(message2.id)
	expect(component.vm.minId).to.eql(message2.id)
	})
	})

	describe('cullOlder', () => {
	it('keeps 50 newest messages and messagesIndex matches', () => {
	for (let i = 100; i > 0; i--) {
	// Use decimal values with toFixed to hack together constant length predictable strings
	component.vm.addMessages({
	messages: [
	{
	...message1,
	id: 'a' + (i / 1000).toFixed(3),
	idempotency_key: i,
	},
	],
	})
	}
	component.vm.cullOlder()
	- expect(component.vm.messages.length).to.eql(50)
	+ expect(component.vm.messages).to.have.length(50)
	expect(component.vm.messages[0].id).to.eql('a0.051')
	expect(component.vm.minId).to.eql('a0.051')
	expect(component.vm.messages[49].id).to.eql('a0.100')
	- expect(Object.keys(component.vm.messagesIndex).length).to.eql(50)
	+ expect(Object.keys(component.vm.messagesIndex)).to.have.length(50)
	})
	})
	})
	diff --git a/test/unit/specs/modules/statuses.spec.js b/test/unit/specs/modules/statuses.spec.js
	index cd43496a92..04bd07ffec 100644
	--- a/test/unit/specs/modules/statuses.spec.js
	+++ b/test/unit/specs/modules/statuses.spec.js
	@@ -1,447 +1,447 @@
	import { createTestingPinia } from '@pinia/testing'

	import {
	defaultState,
	mutations,
	prepareStatus,
	} from '../../../../src/modules/statuses.js'

	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.equal('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.equal('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).to.have.length(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).to.have.length(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).to.have.length(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.equal('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.equal('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)
	+ expect(state.allStatusesObject['1'].emoji_reactions).to.have.length(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.visibleStatuses).to.have.length(2)
	expect(state.timelines.public.minVisibleId).to.equal('10')
	expect(state.timelines.public.minId).to.equal('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/sync_config.spec.js b/test/unit/specs/stores/sync_config.spec.js
	index a045aa18ae..d2e6d42d31 100644
	--- a/test/unit/specs/stores/sync_config.spec.js
	+++ b/test/unit/specs/stores/sync_config.spec.js
	@@ -1,674 +1,674 @@
	import { cloneDeep } from 'lodash'
	import { createPinia, setActivePinia } from 'pinia'

	import {
	_getAllFlags,
	_getRecentData,
	_mergeFlags,
	_mergePrefs,
	_moveItemInArray,
	_resetFlags,
	COMMAND_TRIM_FLAGS,
	COMMAND_TRIM_FLAGS_AND_RESET,
	defaultState,
	newUserFlags,
	useSyncConfigStore,
	VERSION,
	} from 'src/stores/sync_config.js'

	describe('The SyncConfig store', () => {
	beforeEach(() => {
	setActivePinia(createPinia())
	})

	describe('mutations', () => {
	describe('initSyncConfig', () => {
	const user = {
	created_at: new Date('1999-02-09'),
	storage: {},
	}

	it('should initialize storage if none present', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	await store.initSyncConfig({ ...user })
	expect(store.cache._version).to.eql(VERSION)
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.flagStorage).to.eql(defaultState.flagStorage)
	expect(store.cache.prefsStorage).to.eql(defaultState.prefsStorage)
	})

	it('should initialize storage with proper flags for new users if none present', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	await store.initSyncConfig({ ...user, created_at: new Date() })
	expect(store.cache._version).to.eql(VERSION)
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.flagStorage).to.eql(newUserFlags)
	expect(store.cache.prefsStorage).to.eql(defaultState.prefsStorage)
	})

	it('should merge flags even if remote timestamp is older', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.cache = {
	_timestamp: Date.now(),
	_version: VERSION,
	...cloneDeep(defaultState),
	}

	await store.initSyncConfig({
	...user,
	storage: {
	_timestamp: 123,
	_version: VERSION,
	flagStorage: {
	...defaultState.flagStorage,
	updateCounter: 1,
	},
	prefsStorage: {
	...defaultState.prefsStorage,
	},
	},
	})

	expect(store.flagStorage).to.eql({
	...defaultState.flagStorage,
	updateCounter: 1,
	})
	})

	it('should trim journal to 500 entries', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.cache = {
	_timestamp: Date.now(),
	_version: VERSION,
	...cloneDeep(defaultState),
	}
	const largeJournal = []
	for (let value = 0; value < 1000; value++) {
	largeJournal.push({
	path: 'simple.palette' + value,
	operation: 'set',
	args: [value],
	// should have A timestamp, we don't really care what it is
	timestamp: 123456,
	})
	}

	await store.initSyncConfig({
	...user,
	storage: {
	_timestamp: 123,
	_version: VERSION,
	flagStorage: {
	...defaultState.flagStorage,
	updateCounter: 1,
	},
	prefsStorage: {
	...defaultState.prefsStorage,
	_journal: largeJournal,
	},
	},
	})

	- expect(store.prefsStorage._journal.length).to.eql(500)
	+ expect(store.prefsStorage._journal).to.have.length(500)
	})

	it('should reset local timestamp to remote if contents are the same', async () => {
	const store = useSyncConfigStore()
	store.cache = null
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}

	await store.initSyncConfig({
	...user,
	storage: {
	_timestamp: 123,
	_version: VERSION,
	flagStorage: {
	...defaultState.flagStorage,
	updateCounter: 999,
	},
	},
	})
	expect(store.cache._timestamp).to.eql(123)
	expect(store.flagStorage.updateCounter).to.eql(999)
	expect(store.cache.flagStorage.updateCounter).to.eql(999)
	})

	it('should use remote version if local missing', async () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	await store.initSyncConfig(store, user)
	expect(store.cache._version).to.eql(VERSION)
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.flagStorage).to.eql(defaultState.flagStorage)
	})
	})
	describe('setPreference', () => {
	it('should set preference and update journal log accordingly', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.palette', value: '1' })
	expect(store.prefsStorage.simple.palette).to.eql('1')
	- expect(store.prefsStorage._journal.length).to.eql(1)
	+ expect(store.prefsStorage._journal).to.have.length(1)
	expect(store.prefsStorage._journal[0]).to.eql({
	path: 'simple.palette',
	operation: 'set',
	args: ['1'],
	// should have A timestamp, we don't really care what it is
	timestamp: store.prefsStorage._journal[0].timestamp,
	})
	})

	it('should keep journal to a minimum', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.palette', value: 1 })
	store.setPreference({ path: 'simple.palette', value: 2 })
	store.addCollectionPreference({ path: 'collections.palette', value: 2 })
	store.removeCollectionPreference({
	path: 'collections.palette',
	value: 2,
	})
	store.updateCache({ username: 'test' })
	expect(store.prefsStorage.simple.palette).to.eql(2)
	expect(store.prefsStorage.collections.palette).to.eql([])
	- expect(store.prefsStorage._journal.length).to.eql(2)
	+ expect(store.prefsStorage._journal).to.have.length(2)
	expect(store.prefsStorage._journal[0]).to.eql({
	path: 'simple.palette',
	operation: 'set',
	args: [2],
	// should have A timestamp, we don't really care what it is
	timestamp: store.prefsStorage._journal[0].timestamp,
	})
	expect(store.prefsStorage._journal[1]).to.eql({
	path: 'collections.palette',
	operation: 'removeFromCollection',
	args: [2],
	// should have A timestamp, we don't really care what it is
	timestamp: store.prefsStorage._journal[1].timestamp,
	})
	})

	it('should remove duplicate entries from journal', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.palette', value: 1 })
	store.setPreference({ path: 'simple.palette', value: 1 })
	store.addCollectionPreference({ path: 'collections.palette', value: 2 })
	store.addCollectionPreference({ path: 'collections.palette', value: 2 })
	store.updateCache({ username: 'test' })
	expect(store.prefsStorage.simple.palette).to.eql(1)
	expect(store.prefsStorage.collections.palette).to.eql([2])
	- expect(store.prefsStorage._journal.length).to.eql(2)
	+ expect(store.prefsStorage._journal).to.have.length(2)
	})

	// TODO We need a proper test for object-based stores
	it.skip('should remove depth = 3 set/unset entries from journal', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.fontInput', value: 'test' })
	store.unsetPreference({ path: 'simple.fontInput' })
	store.updateCache(store, { username: 'test' })
	expect(store.prefsStorage.simple.fontInput).to.not.have.property(
	'family',
	)
	- expect(store.prefsStorage._journal.length).to.eql(1)
	+ expect(store.prefsStorage._journal).to.have.length(1)
	})

	it('should not allow unsetting depth <= 2', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.object.foo', value: 1 })
	expect(() => store.unsetPreference({ path: 'simple' })).to.throw()
	expect(() =>
	store.unsetPreference({ path: 'simple.object' }),
	).to.throw()
	})

	it('should not allow (un)setting depth > 3', () => {
	const store = useSyncConfigStore()
	// PushSyncConfig is very simple but uses vuex to push data
	store.pushSyncConfig = () => {
	/* no-op */
	}
	store.setPreference({ path: 'simple.object', value: {} })
	expect(() =>
	store.setPreference({ path: 'simple.object.lv3', value: 1 }),
	).to.not.throw()
	expect(() =>
	store.setPreference({ path: 'simple.object.lv3.lv4', value: 1 }),
	).to.throw()
	expect(() =>
	store.unsetPreference({ path: 'simple.object.lv3', value: 1 }),
	).to.not.throw()
	expect(() =>
	store.unsetPreference({ path: 'simple.object.lv3.lv4', value: 1 }),
	).to.throw()
	})
	})
	})

	describe('helper functions', () => {
	describe('_moveItemInArray', () => {
	it('should move item according to movement value', () => {
	expect(_moveItemInArray([1, 2, 3, 4], 4, -1)).to.eql([1, 2, 4, 3])
	expect(_moveItemInArray([1, 2, 3, 4], 1, 2)).to.eql([2, 3, 1, 4])
	})
	it('should clamp movement to within array', () => {
	expect(_moveItemInArray([1, 2, 3, 4], 4, -10)).to.eql([4, 1, 2, 3])
	expect(_moveItemInArray([1, 2, 3, 4], 3, 99)).to.eql([1, 2, 4, 3])
	})
	})
	describe('_getRecentData', () => {
	it('should handle nulls correctly', () => {
	expect(_getRecentData(null, null, true)).to.eql({
	recent: null,
	stale: null,
	needUpload: true,
	})
	})

	it("doesn't choke on invalid data", () => {
	expect(_getRecentData({ a: 1 }, { b: 2 }, true)).to.eql({
	recent: null,
	stale: null,
	needUpload: true,
	})
	})

	it('should prefer the valid non-null correctly, needUpload works properly', () => {
	const nonNull = { _version: VERSION, _timestamp: 1 }
	expect(_getRecentData(nonNull, null, true)).to.eql({
	recent: nonNull,
	stale: null,
	needUpload: true,
	})
	expect(_getRecentData(null, nonNull, true)).to.eql({
	recent: nonNull,
	stale: null,
	needUpload: false,
	})
	})

	it('should prefer the one with higher timestamp', () => {
	const a = { _version: VERSION, _timestamp: 1 }
	const b = { _version: VERSION, _timestamp: 2 }

	expect(_getRecentData(a, b, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	expect(_getRecentData(b, a, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	})

	it('case where both are same', () => {
	const a = { _version: VERSION, _timestamp: 3 }
	const b = { _version: VERSION, _timestamp: 3 }

	expect(_getRecentData(a, b, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	expect(_getRecentData(b, a, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	})
	})

	describe('_getAllFlags', () => {
	it('should handle nulls properly', () => {
	expect(_getAllFlags(null, null)).to.eql([])
	})
	it('should output list of keys if passed single object', () => {
	expect(
	_getAllFlags({ flagStorage: { a: 1, b: 1, c: 1 } }, null),
	).to.eql(['a', 'b', 'c'])
	})
	it('should union keys of both objects', () => {
	expect(
	_getAllFlags(
	{ flagStorage: { a: 1, b: 1, c: 1 } },
	{ flagStorage: { c: 1, d: 1 } },
	),
	).to.eql(['a', 'b', 'c', 'd'])
	})
	})

	describe('_mergeFlags', () => {
	it('should handle merge two flag sets correctly picking higher numbers', () => {
	expect(
	_mergeFlags(
	{ flagStorage: { a: 0, b: 3 } },
	{ flagStorage: { b: 1, c: 4, d: 9 } },
	['a', 'b', 'c', 'd'],
	),
	).to.eql({ a: 0, b: 3, c: 4, d: 9 })
	})
	})

	describe('_mergePrefs', () => {
	it('should prefer recent and apply journal to it', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { theme: '1', style: '0', hideISP: true },
	_journal: [
	{
	path: 'simple.style',
	operation: 'set',
	args: ['0'],
	timestamp: 2,
	},
	{
	path: 'simple.hideISP',
	operation: 'set',
	args: [true],
	timestamp: 4,
	},
	],
	},
	// STALE
	{
	simple: { theme: '1', style: '1', hideISP: false },
	_journal: [
	{
	path: 'simple.theme',
	operation: 'set',
	args: ['1'],
	timestamp: 1,
	},
	{
	path: 'simple.style',
	operation: 'set',
	args: ['1'],
	timestamp: 3,
	},
	],
	},
	),
	).to.eql({
	simple: { theme: '1', style: '1', hideISP: true },
	_journal: [
	{
	path: 'simple.theme',
	operation: 'set',
	args: ['1'],
	timestamp: 1,
	},
	{
	path: 'simple.style',
	operation: 'set',
	args: ['1'],
	timestamp: 3,
	},
	{
	path: 'simple.hideISP',
	operation: 'set',
	args: [true],
	timestamp: 4,
	},
	],
	})
	})

	it('should allow setting falsy values', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { theme: '1', style: '0', hideISP: false },
	_journal: [
	{
	path: 'simple.style',
	operation: 'set',
	args: ['0'],
	timestamp: 2,
	},
	{
	path: 'simple.hideISP',
	operation: 'set',
	args: [false],
	timestamp: 4,
	},
	],
	},
	// STALE
	{
	simple: { theme: '0', style: '0', hideISP: true },
	_journal: [
	{
	path: 'simple.theme',
	operation: 'set',
	args: ['0'],
	timestamp: 1,
	},
	{
	path: 'simple.style',
	operation: 'set',
	args: ['0'],
	timestamp: 3,
	},
	],
	},
	),
	).to.eql({
	simple: { theme: '0', style: '0', hideISP: false },
	_journal: [
	{
	path: 'simple.theme',
	operation: 'set',
	args: ['0'],
	timestamp: 1,
	},
	{
	path: 'simple.style',
	operation: 'set',
	args: ['0'],
	timestamp: 3,
	},
	{
	path: 'simple.hideISP',
	operation: 'set',
	args: [false],
	timestamp: 4,
	},
	],
	})
	})

	it('should work with strings', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { theme: 'foo' },
	_journal: [
	{
	path: 'simple.theme',
	operation: 'set',
	args: ['foo'],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	simple: { theme: 'bar' },
	_journal: [
	{
	path: 'simple.theme',
	operation: 'set',
	args: ['bar'],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	simple: { theme: 'bar' },
	_journal: [
	{
	path: 'simple.theme',
	operation: 'set',
	args: ['bar'],
	timestamp: 4,
	},
	],
	})
	})

	it('should work with objects', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { fontInput: { lv3: 'foo' } },
	_journal: [
	{
	path: 'simple.fontInput.lv3',
	operation: 'set',
	args: ['foo'],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	simple: { fontInput: { lv3: 'bar' } },
	_journal: [
	{
	path: 'simple.fontInput.lv3',
	operation: 'set',
	args: ['bar'],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	simple: { fontInput: { lv3: 'bar' } },
	_journal: [
	{
	path: 'simple.fontInput.lv3',
	operation: 'set',
	args: ['bar'],
	timestamp: 4,
	},
	],
	})
	})

	it('should work with unset', () => {
	expect(
	_mergePrefs(
	// RECENT
	{
	simple: { fontInput: { lv3: 'foo' } },
	_journal: [
	{
	path: 'simple.fontInput.lv3',
	operation: 'set',
	args: ['foo'],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	simple: { fontInput: {} },
	_journal: [
	{
	path: 'simple.fontInput.lv3',
	operation: 'unset',
	args: [],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	simple: { fontInput: {} },
	_journal: [
	{
	path: 'simple.fontInput.lv3',
	operation: 'unset',
	args: [],
	timestamp: 4,
	},
	],
	})
	})
	})

	describe('_resetFlags', () => {
	it('should trim all flags to known when reset is set to 1000', () => {
	const totalFlags = { a: 0, b: 3, c: 33, reset: COMMAND_TRIM_FLAGS }

	expect(_resetFlags(totalFlags, { a: 0, b: 0, reset: 0 })).to.eql({
	a: 0,
	b: 3,
	reset: 0,
	})
	})
	it('should trim all flags to known and reset when reset is set to 1001', () => {
	const totalFlags = {
	a: 0,
	b: 3,
	c: 33,
	reset: COMMAND_TRIM_FLAGS_AND_RESET,
	}

	expect(_resetFlags(totalFlags, { a: 0, b: 0, reset: 0 })).to.eql({
	a: 0,
	b: 0,
	reset: 0,
	})
	})
	})
	})
	})
	diff --git a/test/unit/specs/stores/user_highlight.spec.js b/test/unit/specs/stores/user_highlight.spec.js
	index f80143b6e0..e97f8f3826 100644
	--- a/test/unit/specs/stores/user_highlight.spec.js
	+++ b/test/unit/specs/stores/user_highlight.spec.js
	@@ -1,314 +1,314 @@
	import { createPinia, setActivePinia } from 'pinia'

	import {
	_getRecentData,
	_mergeHighlights,
	useUserHighlightStore,
	} from 'src/stores/user_highlight.js'

	describe('The UserHighlight store', () => {
	beforeEach(() => {
	setActivePinia(createPinia())
	window.vuex = {
	state: {
	users: {
	currentUser: {
	fqn: 'foo@bar.tld',
	},
	},
	},
	}
	})

	describe('mutations', () => {
	describe('initUserHighlight', () => {
	const user = {
	created_at: new Date('1999-02-09'),
	storage: {},
	}

	it('should initialize storage if none present', async () => {
	const store = useUserHighlightStore()
	await store.initUserHighlight({ ...user })
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.highlight).to.eql({ _journal: [] })
	})

	it('should initialize storage for new users if none present', async () => {
	const store = useUserHighlightStore()
	await store.initUserHighlight({ ...user, created_at: new Date() })
	expect(store.cache._timestamp).to.be.a('number')
	expect(store.cache.highlight).to.eql({ _journal: [] })
	})

	it('should use remote version if local missing', async () => {
	const store = useUserHighlightStore()
	await store.initUserHighlight(store, user)
	expect(store.cache._timestamp).to.be.a('number')
	})
	})
	describe('set', () => {
	it('should set preference and update journal log accordingly', () => {
	const store = useUserHighlightStore()
	store.set({ user: 'highlight@testing', value: { type: 'test' } })
	expect(store.highlight['highlight@testing']).to.eql({
	user: 'highlight@testing',
	type: 'test',
	})
	- expect(store.highlight._journal.length).to.eql(1)
	+ expect(store.highlight._journal).to.have.length(1)
	expect(store.highlight._journal[0]).to.eql({
	user: 'highlight@testing',
	operation: 'set',
	args: [{ user: 'highlight@testing', type: 'test' }],
	// should have A timestamp, we don't really care what it is
	timestamp: store.highlight._journal[0].timestamp,
	})
	})

	it('should keep journal to a minimum', () => {
	const store = useUserHighlightStore()
	store.set({ user: 'highlight@testing.xyz', value: { type: 'test' } })
	store.set({ user: 'highlight@testing.xyz', value: { type: 'test' } })
	store.updateCache({ username: 'test' })
	expect(store.highlight['highlight@testing.xyz']).to.eql({
	user: 'highlight@testing.xyz',
	type: 'test',
	})
	- expect(store.highlight._journal.length).to.eql(1)
	+ expect(store.highlight._journal).to.have.length(1)
	expect(store.highlight._journal[0]).to.eql({
	user: 'highlight@testing.xyz',
	operation: 'set',
	args: [
	{
	user: 'highlight@testing.xyz',
	type: 'test',
	},
	],
	// should have A timestamp, we don't really care what it is
	timestamp: store.highlight._journal[0].timestamp,
	})
	})

	it('should remove duplicate entries from journal', () => {
	const store = useUserHighlightStore()
	store.set({ user: 'a@test.xyz', value: { type: 'foo' } })
	store.set({ user: 'a@test.xyz', value: { type: 'foo' } })
	store.updateCache({ username: 'test' })
	expect(store.highlight['a@test.xyz']).to.eql({
	user: 'a@test.xyz',
	type: 'foo',
	})
	- expect(store.highlight._journal.length).to.eql(1)
	+ expect(store.highlight._journal).to.have.length(1)
	})
	})
	})

	describe('helper functions', () => {
	describe('_getRecentData', () => {
	it('should handle nulls correctly', () => {
	expect(_getRecentData(null, null, true)).to.eql({
	recent: null,
	stale: null,
	needUpload: true,
	})
	})

	it("doesn't choke on invalid data", () => {
	expect(_getRecentData({ a: 1 }, { b: 2 }, true)).to.eql({
	recent: null,
	stale: null,
	needUpload: true,
	})
	})

	it('should prefer the valid non-null correctly, needUpload works properly', () => {
	const nonNull = { _timestamp: 1 }
	expect(_getRecentData(nonNull, null, true)).to.eql({
	recent: nonNull,
	stale: null,
	needUpload: true,
	})
	expect(_getRecentData(null, nonNull, true)).to.eql({
	recent: nonNull,
	stale: null,
	needUpload: false,
	})
	})

	it('should prefer the one with higher timestamp', () => {
	const a = { _timestamp: 1 }
	const b = { _timestamp: 2 }

	expect(_getRecentData(a, b, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	expect(_getRecentData(b, a, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	})

	it('case where both are same', () => {
	const a = { _timestamp: 3 }
	const b = { _timestamp: 3 }

	expect(_getRecentData(a, b, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	expect(_getRecentData(b, a, true)).to.eql({
	recent: b,
	stale: a,
	needUpload: false,
	})
	})
	})

	describe('_mergeHighlights', () => {
	it('should prefer recent and apply journal to it', () => {
	expect(
	_mergeHighlights(
	{
	// RECENT
	'a@test.xyz': 1,
	'b@test.xyz': 0,
	'c@test.xyz': true,
	_journal: [
	{
	user: 'b@test.xyz',
	operation: 'set',
	args: [0],
	timestamp: 2,
	},
	{
	user: 'c@test.xyz',
	operation: 'set',
	args: [true],
	timestamp: 4,
	},
	],
	},
	{
	// STALE
	'a@test.xyz': 1,
	'b@test.xyz': 1,
	'c@test.xyz': false,
	_journal: [
	{
	user: 'a@test.xyz',
	operation: 'set',
	args: [1],
	timestamp: 1,
	},
	{
	user: 'b@test.xyz',
	operation: 'set',
	args: [1],
	timestamp: 3,
	},
	],
	},
	),
	).to.eql({
	'a@test.xyz': 1,
	'b@test.xyz': 1,
	'c@test.xyz': true,
	_journal: [
	{ user: 'a@test.xyz', operation: 'set', args: [1], timestamp: 1 },
	{ user: 'b@test.xyz', operation: 'set', args: [1], timestamp: 3 },
	{
	user: 'c@test.xyz',
	operation: 'set',
	args: [true],
	timestamp: 4,
	},
	],
	})
	})

	it('should work with objects', () => {
	expect(
	_mergeHighlights(
	// RECENT
	{
	'a@test.xyz': { type: 'foo' },
	_journal: [
	{
	user: 'a@test.xyz',
	operation: 'set',
	args: [{ type: 'foo' }],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	'a@test.xyz': { type: 'bar' },
	_journal: [
	{
	user: 'a@test.xyz',
	operation: 'set',
	args: [{ type: 'bar' }],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	'a@test.xyz': { type: 'bar' },
	_journal: [
	{
	user: 'a@test.xyz',
	operation: 'set',
	args: [{ type: 'bar' }],
	timestamp: 4,
	},
	],
	})
	})

	it('should work with unset', () => {
	expect(
	_mergeHighlights(
	// RECENT
	{
	'a@test.xyz': { type: 'foo' },
	_journal: [
	{
	user: 'a@test.xyz',
	operation: 'set',
	args: [{ type: 'foo' }],
	timestamp: 2,
	},
	],
	},
	// STALE
	{
	_journal: [
	{
	user: 'a@test.xyz',
	operation: 'unset',
	args: [],
	timestamp: 4,
	},
	],
	},
	),
	).to.eql({
	_journal: [
	{
	user: 'a@test.xyz',
	operation: 'unset',
	args: [],
	timestamp: 4,
	},
	],
	})
	})
	})
	})
	})

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 8, 1:12 PM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1723488
Default Alt Text: (50 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions