No OneTemporary
Actions

Size

40 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/modules/statuses.js b/src/modules/statuses.js
	index 7571b62abd..6b512fa372 100644
	--- a/src/modules/statuses.js
	+++ b/src/modules/statuses.js
	@@ -1,481 +1,482 @@
	import { remove, slice, each, find, maxBy, minBy, merge, first, last, isArray } from 'lodash'
	import apiService from '../services/api/api.service.js'
	// import parse from '../services/status_parser/status_parser.js'

	const emptyTl = (userId = 0) => ({
	statuses: [],
	statusesObject: {},
	faves: [],
	visibleStatuses: [],
	visibleStatusesObject: {},
	newStatusCount: 0,
	maxId: 0,
	minId: 0,
	minVisibleId: 0,
	loading: false,
	followers: [],
	friends: [],
	userId,
	flushMarker: 0
	})

	export const defaultState = () => ({
	allStatuses: [],
	allStatusesObject: {},
	maxId: 0,
	notifications: {
	desktopNotificationSilence: true,
	maxId: 0,
	minId: Number.POSITIVE_INFINITY,
	data: [],
	idStore: {},
	loading: false,
	error: false,
	fetcherId: null
	},
	favorites: new Set(),
	error: false,
	timelines: {
	mentions: emptyTl(),
	public: emptyTl(),
	user: emptyTl(),
	favorites: emptyTl(),
	media: emptyTl(),
	publicAndExternal: emptyTl(),
	friends: emptyTl(),
	tag: emptyTl(),
	dms: emptyTl()
	}
	})

	export const prepareStatus = (status) => {
	// Set deleted flag
	status.deleted = false

	// To make the array reactive
	status.attachments = status.attachments \|\| []

	return status
	}

	const visibleNotificationTypes = (rootState) => {
	return [
	rootState.config.notificationVisibility.likes && 'like',
	rootState.config.notificationVisibility.mentions && 'mention',
	rootState.config.notificationVisibility.repeats && 'repeat',
	rootState.config.notificationVisibility.follows && 'follow'
	].filter(_ => _)
	}

	const mergeOrAdd = (arr, obj, item) => {
	const oldItem = obj[item.id]

	if (oldItem) {
	// We already have this, so only merge the new info.
	merge(oldItem, item)
	// Reactivity fix.
	oldItem.attachments.splice(oldItem.attachments.length)
	return {item: oldItem, new: false}
	} else {
	// This is a new item, prepare it
	prepareStatus(item)
	arr.push(item)
	obj[item.id] = item
	return {item, new: true}
	}
	}

	const sortById = (a, b) => {
	const seqA = Number(a.id)
	const seqB = Number(b.id)
	const isSeqA = !Number.isNaN(seqA)
	const isSeqB = !Number.isNaN(seqB)
	if (isSeqA && isSeqB) {
	return seqA > seqB ? -1 : 1
	} else if (isSeqA && !isSeqB) {
	return 1
	} else if (!isSeqA && isSeqB) {
	return -1
	} else {
	return a.id > b.id ? -1 : 1
	}
	}

	const sortTimeline = (timeline) => {
	timeline.visibleStatuses = timeline.visibleStatuses.sort(sortById)
	timeline.statuses = timeline.statuses.sort(sortById)
	timeline.minVisibleId = (last(timeline.visibleStatuses) \|\| {}).id
	return timeline
	}

	const addNewStatuses = (state, { statuses, showImmediately = false, timeline, user = {}, noIdUpdate = false, userId }) => {
	// Sanity check
	if (!isArray(statuses)) {
	return false
	}

	const allStatuses = state.allStatuses
	const allStatusesObject = state.allStatusesObject
	const timelineObject = state.timelines[timeline]

	const maxNew = statuses.length > 0 ? maxBy(statuses, 'id').id : 0
	const minNew = statuses.length > 0 ? minBy(statuses, 'id').id : 0
	const newer = timeline && maxNew > timelineObject.maxId && statuses.length > 0
	const older = timeline && (minNew < timelineObject.minId \|\| timelineObject.minId === 0) && statuses.length > 0

	if (!noIdUpdate && newer) {
	timelineObject.maxId = maxNew
	}
	if (!noIdUpdate && older) {
	timelineObject.minId = minNew
	}

	// This makes sure that user timeline won't get data meant for other
	// user. I.e. opening different user profiles makes request which could
	// return data late after user already viewing different user profile
	if ((timeline === 'user' \|\| timeline === 'media') && timelineObject.userId !== userId) {
	return
	}

	const addStatus = (data, showImmediately, addToTimeline = true) => {
	const result = mergeOrAdd(allStatuses, allStatusesObject, data)
	const status = result.item

	if (result.new) {
	// We are mentioned in a post
	if (status.type === 'status' && find(status.attentions, { id: user.id })) {
	const mentions = state.timelines.mentions

	// Add the mention to the mentions timeline
	if (timelineObject !== mentions) {
	mergeOrAdd(mentions.statuses, mentions.statusesObject, status)
	mentions.newStatusCount += 1

	sortTimeline(mentions)
	}
	}
	if (status.visibility === 'direct') {
	const dms = state.timelines.dms

	mergeOrAdd(dms.statuses, dms.statusesObject, status)
	dms.newStatusCount += 1

	sortTimeline(dms)
	}
	}

	// Decide if we should treat the status as new for this timeline.
	let resultForCurrentTimeline
	// Some statuses should only be added to the global status repository.
	if (timeline && addToTimeline) {
	resultForCurrentTimeline = mergeOrAdd(timelineObject.statuses, timelineObject.statusesObject, status)
	}

	if (timeline && showImmediately) {
	// Add it directly to the visibleStatuses, don't change
	// newStatusCount
	mergeOrAdd(timelineObject.visibleStatuses, timelineObject.visibleStatusesObject, status)
	} else if (timeline && addToTimeline && resultForCurrentTimeline.new) {
	// Just change newStatuscount
	timelineObject.newStatusCount += 1
	}

	return status
	}

	const favoriteStatus = (favorite, counter) => {
	const status = find(allStatuses, { id: favorite.in_reply_to_status_id })
	if (status) {
	// This is our favorite, so the relevant bit.
	if (favorite.user.id === user.id) {
	status.favorited = true
	} else {
	status.fave_num += 1
	}
	}
	return status
	}

	const processors = {
	'status': (status) => {
	addStatus(status, showImmediately)
	},
	'retweet': (status) => {
	// RetweetedStatuses are never shown immediately
	const retweetedStatus = addStatus(status.retweeted_status, false, false)

	let retweet
	// If the retweeted status is already there, don't add the retweet
	// to the timeline.
	if (timeline && find(timelineObject.statuses, (s) => {
	if (s.retweeted_status) {
	return s.id === retweetedStatus.id \|\| s.retweeted_status.id === retweetedStatus.id
	} else {
	return s.id === retweetedStatus.id
	}
	})) {
	// Already have it visible (either as the original or another RT), don't add to timeline, don't show.
	retweet = addStatus(status, false, false)
	} else {
	retweet = addStatus(status, showImmediately)
	}

	retweet.retweeted_status = retweetedStatus
	},
	'favorite': (favorite) => {
	// Only update if this is a new favorite.
	// Ignore our own favorites because we get info about likes as response to like request
	if (!state.favorites.has(favorite.id)) {
	state.favorites.add(favorite.id)
	favoriteStatus(favorite)
	}
	},
	'deletion': (deletion) => {
	const uri = deletion.uri

	// Remove possible notification
	const status = find(allStatuses, {uri})
	if (!status) {
	return
	}

	remove(state.notifications.data, ({action: {id}}) => id === status.id)

	remove(allStatuses, { uri })
	if (timeline) {
	remove(timelineObject.statuses, { uri })
	remove(timelineObject.visibleStatuses, { uri })
	}
	},
	'follow': (follow) => {
	// NOOP, it is known status but we don't do anything about it for now
	},
	'default': (unknown) => {
	console.log('unknown status type')
	console.log(unknown)
	}
	}

	each(statuses, (status) => {
	const type = status.type
	const processor = processors[type] \|\| processors['default']
	processor(status)
	})

	// Keep the visible statuses sorted
	if (timeline) {
	sortTimeline(timelineObject)
	}
	}

	const addNewNotifications = (state, { dispatch, notifications, older, visibleNotificationTypes }) => {
	const allStatuses = state.allStatuses
	const allStatusesObject = state.allStatusesObject
	each(notifications, (notification) => {
	notification.action = mergeOrAdd(allStatuses, allStatusesObject, notification.action).item
	notification.status = notification.status && mergeOrAdd(allStatuses, allStatusesObject, notification.status).item

	// Only add a new notification if we don't have one for the same action
	if (!state.notifications.idStore.hasOwnProperty(notification.id)) {
	state.notifications.maxId = notification.id > state.notifications.maxId
	? notification.id
	: state.notifications.maxId
	state.notifications.minId = notification.id < state.notifications.minId
	? notification.id
	: state.notifications.minId

	state.notifications.data.push(notification)
	state.notifications.idStore[notification.id] = notification

	if ('Notification' in window && window.Notification.permission === 'granted') {
	const notifObj = {}
	const action = notification.action
	const title = action.user.name
	notifObj.icon = action.user.profile_image_url
	notifObj.body = action.text // there's a problem that it doesn't put a space before links tho

	// Shows first attached non-nsfw image, if any. Should add configuration for this somehow...
	if (action.attachments && action.attachments.length > 0 && !action.nsfw &&
	action.attachments[0].mimetype.startsWith('image/')) {
	notifObj.image = action.attachments[0].url
	}

	if (!notification.seen && !state.notifications.desktopNotificationSilence && visibleNotificationTypes.includes(notification.type)) {
	let notification = new window.Notification(title, notifObj)
	// Chrome is known for not closing notifications automatically
	// according to MDN, anyway.
	setTimeout(notification.close.bind(notification), 5000)
	}
	}
	} else if (notification.seen) {
	state.notifications.idStore[notification.id].seen = true
	}
	})
	}

	const removeStatus = (state, { timeline, userId }) => {
	const timelineObject = state.timelines[timeline]
	if (userId) {
	remove(timelineObject.statuses, { user: { id: userId } })
	remove(timelineObject.visibleStatuses, { user: { id: userId } })
	timelineObject.minVisibleId = timelineObject.visibleStatuses.length > 0 ? last(timelineObject.visibleStatuses).id : 0
	timelineObject.maxId = timelineObject.statuses.length > 0 ? first(timelineObject.statuses).id : 0
	}
	}

	export const mutations = {
	addNewStatuses,
	addNewNotifications,
	removeStatus,
	showNewStatuses (state, { timeline }) {
	const oldTimeline = (state.timelines[timeline])

	oldTimeline.newStatusCount = 0
	oldTimeline.visibleStatuses = slice(oldTimeline.statuses, 0, 50)
	oldTimeline.minVisibleId = last(oldTimeline.visibleStatuses).id
	+ oldTimeline.minId = oldTimeline.minVisibleId
	oldTimeline.visibleStatusesObject = {}
	each(oldTimeline.visibleStatuses, (status) => { oldTimeline.visibleStatusesObject[status.id] = status })
	},
	setNotificationFetcher (state, { fetcherId }) {
	state.notifications.fetcherId = fetcherId
	},
	resetStatuses (state) {
	const emptyState = defaultState()
	Object.entries(emptyState).forEach(([key, value]) => {
	state[key] = value
	})
	},
	clearTimeline (state, { timeline }) {
	state.timelines[timeline] = emptyTl(state.timelines[timeline].userId)
	},
	setFavorited (state, { status, value }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.favorited = value
	},
	setFavoritedConfirm (state, { status }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.favorited = status.favorited
	newStatus.fave_num = status.fave_num
	},
	setRetweeted (state, { status, value }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.repeated = value
	},
	setDeleted (state, { status }) {
	const newStatus = state.allStatusesObject[status.id]
	newStatus.deleted = true
	},
	setLoading (state, { timeline, value }) {
	state.timelines[timeline].loading = value
	},
	setNsfw (state, { id, nsfw }) {
	const newStatus = state.allStatusesObject[id]
	newStatus.nsfw = nsfw
	},
	setError (state, { value }) {
	state.error = value
	},
	setNotificationsLoading (state, { value }) {
	state.notifications.loading = value
	},
	setNotificationsError (state, { value }) {
	state.notifications.error = value
	},
	setNotificationsSilence (state, { value }) {
	state.notifications.desktopNotificationSilence = value
	},
	markNotificationsAsSeen (state) {
	each(state.notifications.data, (notification) => {
	notification.seen = true
	})
	},
	queueFlush (state, { timeline, id }) {
	state.timelines[timeline].flushMarker = id
	}
	}

	const statuses = {
	state: defaultState(),
	actions: {
	addNewStatuses ({ rootState, commit }, { statuses, showImmediately = false, timeline = false, noIdUpdate = false, userId }) {
	commit('addNewStatuses', { statuses, showImmediately, timeline, noIdUpdate, user: rootState.users.currentUser, userId })
	},
	addNewNotifications ({ rootState, commit, dispatch }, { notifications, older }) {
	commit('addNewNotifications', { visibleNotificationTypes: visibleNotificationTypes(rootState), dispatch, notifications, older })
	},
	setError ({ rootState, commit }, { value }) {
	commit('setError', { value })
	},
	setNotificationsLoading ({ rootState, commit }, { value }) {
	commit('setNotificationsLoading', { value })
	},
	setNotificationsError ({ rootState, commit }, { value }) {
	commit('setNotificationsError', { value })
	},
	setNotificationsSilence ({ rootState, commit }, { value }) {
	commit('setNotificationsSilence', { value })
	},
	stopFetchingNotifications ({ rootState, commit }) {
	if (rootState.statuses.notifications.fetcherId) {
	window.clearInterval(rootState.statuses.notifications.fetcherId)
	}
	commit('setNotificationFetcher', { fetcherId: null })
	},
	deleteStatus ({ rootState, commit }, status) {
	commit('setDeleted', { status })
	apiService.deleteStatus({ id: status.id, credentials: rootState.users.currentUser.credentials })
	},
	favorite ({ rootState, commit }, status) {
	// Optimistic favoriting...
	commit('setFavorited', { status, value: true })
	apiService.favorite({ id: status.id, credentials: rootState.users.currentUser.credentials })
	.then(response => {
	if (response.ok) {
	return response.json()
	} else {
	return {}
	}
	})
	.then(status => {
	commit('setFavoritedConfirm', { status })
	})
	},
	unfavorite ({ rootState, commit }, status) {
	// Optimistic favoriting...
	commit('setFavorited', { status, value: false })
	apiService.unfavorite({ id: status.id, credentials: rootState.users.currentUser.credentials })
	.then(response => {
	if (response.ok) {
	return response.json()
	} else {
	return {}
	}
	})
	.then(status => {
	commit('setFavoritedConfirm', { status })
	})
	},
	retweet ({ rootState, commit }, status) {
	// Optimistic retweeting...
	commit('setRetweeted', { status, value: true })
	apiService.retweet({ id: status.id, credentials: rootState.users.currentUser.credentials })
	},
	unretweet ({ rootState, commit }, status) {
	commit('setRetweeted', { status, value: false })
	apiService.unretweet({ id: status.id, credentials: rootState.users.currentUser.credentials })
	},
	queueFlush ({ rootState, commit }, { timeline, id }) {
	commit('queueFlush', { timeline, id })
	},
	markNotificationsAsSeen ({ rootState, commit }) {
	commit('markNotificationsAsSeen')
	apiService.markNotificationsAsSeen({
	id: rootState.statuses.notifications.maxId,
	credentials: rootState.users.currentUser.credentials
	})
	}
	},
	mutations
	}

	export default statuses
	diff --git a/test/unit/specs/modules/statuses.spec.js b/test/unit/specs/modules/statuses.spec.js
	index 864b798dd1..0bbcb25a3e 100644
	--- a/test/unit/specs/modules/statuses.spec.js
	+++ b/test/unit/specs/modules/statuses.spec.js
	@@ -1,306 +1,326 @@
	import { defaultState, mutations, prepareStatus } from '../../../../src/modules/statuses.js'

	// eslint-disable-next-line camelcase
	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.prepareStatus', () => {
	- it('sets deleted flag to false', () => {
	- const aStatus = makeMockStatus({id: '1', text: 'Hello oniichan'})
	- expect(prepareStatus(aStatus).deleted).to.eq(false)
	+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('The Statuses module', () => {
	- it('adds the status to allStatuses and to the given timeline', () => {
	- const state = defaultState()
	- const status = makeMockStatus({id: '1'})
	+ 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' })
	+ 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)
	- })
	+ 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'})
	+ 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' })
	+ 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.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)
	- })
	+ 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'})
	+ it('add the statuses to allStatuses if no timeline is given', () => {
	+ const state = defaultState()
	+ const status = makeMockStatus({id: '1'})

	- mutations.addNewStatuses(state, { statuses: [status] })
	+ 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)
	- })
	+ 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'})
	+ 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' })
	+ 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)
	- })
	+ 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('removes statuses by tag on deletion', () => {
	- const state = defaultState()
	- const status = makeMockStatus({id: '1'})
	- const otherStatus = makeMockStatus({id: '3'})
	- status.uri = 'xxx'
	- const deletion = makeMockStatus({id: '2', type: 'deletion'})
	- deletion.text = 'Dolus deleted notice {{tag:gs.smuglo.li,2016-11-18:noticeId=1038007:objectType=note}}.'
	- deletion.uri = 'xxx'
	-
	- mutations.addNewStatuses(state, { statuses: [status, otherStatus], showImmediately: true, timeline: 'public' })
	- mutations.addNewStatuses(state, { statuses: [deletion], showImmediately: true, timeline: 'public' })
	-
	- expect(state.allStatuses).to.eql([otherStatus])
	- expect(state.timelines.public.statuses).to.eql([otherStatus])
	- expect(state.timelines.public.visibleStatuses).to.eql([otherStatus])
	- expect(state.timelines.public.maxId).to.eql('3')
	- })
	+ it('removes statuses by tag on deletion', () => {
	+ const state = defaultState()
	+ const status = makeMockStatus({id: '1'})
	+ const otherStatus = makeMockStatus({id: '3'})
	+ status.uri = 'xxx'
	+ const deletion = makeMockStatus({id: '2', type: 'deletion'})
	+ deletion.text = 'Dolus deleted notice {{tag:gs.smuglo.li,2016-11-18:noticeId=1038007:objectType=note}}.'
	+ deletion.uri = 'xxx'

	- 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, otherStatus], showImmediately: true, timeline: 'public' })
	+ mutations.addNewStatuses(state, { statuses: [deletion], showImmediately: true, timeline: 'public' })

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

	- 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('does not update the maxId when the noIdUpdate flag is set', () => {
	+ const state = defaultState()
	+ const status = makeMockStatus({id: '1'})
	+ const secondStatus = makeMockStatus({id: '2'})

	- 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: [status], showImmediately: true, timeline: 'public' })
	+ expect(state.timelines.public.maxId).to.eql('1')

	- mutations.addNewStatuses(state, { statuses: [nonVisibleStatus], showImmediately: false, timeline: 'public' })
	+ 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')
	+ })

	- mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })
	- mutations.addNewStatuses(state, { statuses: [statusTwo], showImmediately: true, timeline: 'public' })
	+ 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'})

	- expect(state.timelines.public.minVisibleId).to.equal('2')
	+ mutations.addNewStatuses(state, { statuses: [nonVisibleStatus], showImmediately: false, timeline: 'public' })

	- mutations.addNewStatuses(state, { statuses: [statusThree], showImmediately: true, timeline: 'public' })
	+ mutations.addNewStatuses(state, { statuses: [status], showImmediately: true, timeline: 'public' })
	+ mutations.addNewStatuses(state, { statuses: [statusTwo], 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])
	- })
	+ expect(state.timelines.public.minVisibleId).to.equal('2')

	- 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)
	- })
	+ mutations.addNewStatuses(state, { statuses: [statusThree], showImmediately: true, timeline: 'public' })

	- 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)
	- })
	+ expect(state.timelines.public.statuses).to.eql([statusThree, status, statusTwo, nonVisibleStatus])
	+ expect(state.timelines.public.visibleStatuses).to.eql([statusThree, status, statusTwo])
	+ })

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

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

	- it('keeps userId when clearing user timeline', () => {
	- const state = defaultState()
	- state.timelines.user.userId = 123
	+ describe('clearTimeline', () => {
	+ it('keeps userId when clearing user timeline', () => {
	+ const state = defaultState()
	+ state.timelines.user.userId = 123

	- mutations.clearTimeline(state, { timeline: 'user' })
	+ mutations.clearTimeline(state, { timeline: 'user' })

	- expect(state.timelines.user.userId).to.eql(123)
	+ expect(state.timelines.user.userId).to.eql(123)
	+ })
	})

	describe('notifications', () => {
	it('removes a notification when the notice gets removed', () => {
	const user = { id: '1' }
	const state = defaultState()
	const status = makeMockStatus({id: '1'})
	const otherStatus = makeMockStatus({id: '3'})
	const mentionedStatus = makeMockStatus({id: '2'})
	mentionedStatus.attentions = [user]
	mentionedStatus.uri = 'xxx'
	otherStatus.attentions = [user]

	const deletion = makeMockStatus({id: '4', type: 'deletion'})
	deletion.text = 'Dolus deleted notice {{tag:gs.smuglo.li,2016-11-18:noticeId=1038007:objectType=note}}.'
	deletion.uri = 'xxx'

	mutations.addNewStatuses(state, { statuses: [status, otherStatus], user })
	mutations.addNewNotifications(
	state,
	{
	notifications: [{
	from_profile: { id: '2' },
	id: '998',
	type: 'mention',
	status: otherStatus,
	action: otherStatus,
	seen: false
	}]
	})

	expect(state.notifications.data.length).to.eql(1)
	mutations.addNewNotifications(
	state,
	{
	notifications: [{
	from_profile: { id: '2' },
	id: '999',
	type: 'mention',
	status: mentionedStatus,
	action: mentionedStatus,
	seen: false
	}]
	})

	mutations.addNewStatuses(state, { statuses: [mentionedStatus], user })
	expect(state.allStatuses.length).to.eql(3)
	expect(state.notifications.data.length).to.eql(2)
	expect(state.notifications.data[1].status).to.eql(mentionedStatus)
	expect(state.notifications.data[1].action).to.eql(mentionedStatus)
	expect(state.notifications.data[1].type).to.eql('mention')

	mutations.addNewStatuses(state, { statuses: [deletion], user })
	expect(state.allStatuses.length).to.eql(2)
	expect(state.notifications.data.length).to.eql(1)
	})
	})
	})

File Metadata

Mime Type: text/x-diff
Expires: Sat, Aug 29, 7:05 AM (1 d, 15 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1736854
Default Alt Text: (40 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions