Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { describe, expect, it } from 'vitest'
import {
emptyLinearIssueAttributeFilter,
LINEAR_ISSUE_ATTRIBUTE_FILTER_ID_MAX_LENGTH,
type LinearIssueAttributeFilter
} from './issue-attribute-filter'
import {
defaultLinearIssueViewResumeState,
LINEAR_DISPLAY_PROPERTIES,
normalizeLinearIssueViewResumeState,
resolveLinearIssueViewResumeState,
selectLinearWorkspaceIssueFilter,
serializeLinearIssueViewResumeState,
setLinearWorkspaceIssueFilter,
type LinearIssueViewResumeState
} from './issue-view-resume-state'
function filter(overrides: Partial<LinearIssueAttributeFilter> = {}): LinearIssueAttributeFilter {
return { ...emptyLinearIssueAttributeFilter(), ...overrides }
}
const FILTER_A = filter({ stateIds: ['state-a'], priorities: [1] })
const FILTER_B = filter({ labelIds: ['label-b'], assignee: { kind: 'user', id: 'user-b' } })
describe('resolveLinearIssueViewResumeState', () => {
it('falls back to list/none/priority with every display property when nothing is persisted', () => {
expect(resolveLinearIssueViewResumeState(undefined)).toEqual({
viewMode: 'list',
groupBy: 'none',
orderBy: 'priority',
displayProperties: [...LINEAR_DISPLAY_PROPERTIES],
teamPropertyTouched: false,
filtersByWorkspaceId: {}
})
})
it('restores a complete persisted view', () => {
const persisted: LinearIssueViewResumeState = {
viewMode: 'board',
groupBy: 'assignee',
orderBy: 'updated',
displayProperties: ['state', 'labels'],
teamPropertyTouched: true,
filtersByWorkspaceId: { 'workspace-a': FILTER_A, 'workspace-b': FILTER_B }
}
expect(resolveLinearIssueViewResumeState(persisted)).toEqual(persisted)
})
it('keeps an empty display-property list, which means every property is hidden', () => {
expect(resolveLinearIssueViewResumeState({ displayProperties: [] }).displayProperties).toEqual(
[]
)
})
it('drops unknown display properties and restores catalog order', () => {
const resolved = resolveLinearIssueViewResumeState({
displayProperties: ['updated', 'bogus', 'state']
})
expect(resolved.displayProperties).toEqual(['state', 'updated'])
})
})
describe('normalizeLinearIssueViewResumeState', () => {
it('drops a malformed preference blob entirely', () => {
expect(normalizeLinearIssueViewResumeState('board')).toBeUndefined()
expect(normalizeLinearIssueViewResumeState(null)).toBeUndefined()
expect(normalizeLinearIssueViewResumeState(['board'])).toBeUndefined()
expect(normalizeLinearIssueViewResumeState({ viewMode: 'grid', groupBy: 42 })).toBeUndefined()
})
it('keeps the valid fields when only some of them are corrupt', () => {
const normalized = normalizeLinearIssueViewResumeState({
viewMode: 'board',
groupBy: 'nonsense',
orderBy: 'updated',
teamPropertyTouched: 'yes'
})
expect(normalized).toEqual({
viewMode: 'board',
groupBy: 'none',
orderBy: 'updated',
displayProperties: [...LINEAR_DISPLAY_PROPERTIES],
teamPropertyTouched: false,
filtersByWorkspaceId: {}
})
})
it('drops only the corrupt workspace filter and keeps the healthy ones', () => {
const normalized = normalizeLinearIssueViewResumeState({
viewMode: 'board',
filtersByWorkspaceId: {
'workspace-a': FILTER_A,
'workspace-broken': { stateIds: 'not-an-array' },
'workspace-partial': { stateIds: ['state-x'] },
'': FILTER_B
}
})
expect(normalized?.viewMode).toBe('board')
expect(normalized?.filtersByWorkspaceId).toEqual({ 'workspace-a': FILTER_A })
})
it('drops empty persisted filters and a __proto__ workspace key', () => {
// JSON.parse (unlike an object literal) makes __proto__ an own key, which is how it would arrive from disk.
const normalized = normalizeLinearIssueViewResumeState({
viewMode: 'board',
filtersByWorkspaceId: JSON.parse(
`{"workspace-empty": ${JSON.stringify(emptyLinearIssueAttributeFilter())},
"__proto__": ${JSON.stringify(FILTER_A)}}`
)
})
expect(normalized?.filtersByWorkspaceId).toEqual({})
expect(({} as Record<string, unknown>).stateIds).toBeUndefined()
})
})
describe('isDefaultLinearIssueViewResumeState', () => {
// Returning undefined clears persisted defaults after users revert every setting.
it('drops a serialized default view so reverting a setting clears what was stored', () => {
expect(
normalizeLinearIssueViewResumeState(
serializeLinearIssueViewResumeState(defaultLinearIssueViewResumeState())
)
).toBeUndefined()
})
it.each([
['viewMode', { viewMode: 'board' as const }],
['groupBy', { groupBy: 'status' as const }],
['orderBy', { orderBy: 'updated' as const }],
['teamPropertyTouched', { teamPropertyTouched: true }],
['displayProperties', { displayProperties: ['state' as const] }],
[
'filtersByWorkspaceId',
{ filtersByWorkspaceId: { 'workspace-1': filter({ priorities: [1] }) } }
]
])('keeps a view that differs from the default in %s', (_label, overrides) => {
expect(
normalizeLinearIssueViewResumeState(
serializeLinearIssueViewResumeState({
...defaultLinearIssueViewResumeState(),
...overrides
})
)
).toBeDefined()
})
})
describe('serializeLinearIssueViewResumeState', () => {
it('round-trips a restored view unchanged', () => {
const restored = resolveLinearIssueViewResumeState({
viewMode: 'board',
groupBy: 'team',
orderBy: 'identifier',
displayProperties: ['labels', 'state'],
teamPropertyTouched: true,
filtersByWorkspaceId: { 'workspace-a': FILTER_A }
})
expect(serializeLinearIssueViewResumeState(restored)).toEqual(restored)
})
it('emits display properties in catalog order regardless of toggle order', () => {
const serialized = serializeLinearIssueViewResumeState({
...defaultLinearIssueViewResumeState(),
displayProperties: new Set(['updated', 'state'] as const)
})
expect(serialized.displayProperties).toEqual(['state', 'updated'])
})
it('omits empty filters and canonicalizes the rest', () => {
const serialized = serializeLinearIssueViewResumeState({
...defaultLinearIssueViewResumeState(),
filtersByWorkspaceId: {
'workspace-empty': emptyLinearIssueAttributeFilter(),
'workspace-a': filter({ labelIds: ['b', 'a', 'a'] })
}
})
expect(serialized.filtersByWorkspaceId).toEqual({
'workspace-a': filter({ labelIds: ['a', 'b'] })
})
})
// Overlength IDs can make a nonempty filter empty only after bounding.
it('omits a filter that only becomes empty once bounded', () => {
const serialized = serializeLinearIssueViewResumeState({
...defaultLinearIssueViewResumeState(),
filtersByWorkspaceId: {
'workspace-over-length': filter({
labelIds: ['x'.repeat(LINEAR_ISSUE_ATTRIBUTE_FILTER_ID_MAX_LENGTH + 1)]
})
}
})
expect(serialized.filtersByWorkspaceId).toEqual({})
expect(normalizeLinearIssueViewResumeState(serialized)).toBeUndefined()
})
})
describe('selectLinearWorkspaceIssueFilter', () => {
const filters = { 'workspace-a': FILTER_A, 'workspace-b': FILTER_B }
it('retrieves only the selected workspace filter', () => {
expect(selectLinearWorkspaceIssueFilter(filters, 'workspace-a')).toEqual(FILTER_A)
expect(selectLinearWorkspaceIssueFilter(filters, 'workspace-b')).toEqual(FILTER_B)
})
it('is unfiltered for a workspace with nothing saved', () => {
expect(selectLinearWorkspaceIssueFilter(filters, 'workspace-c')).toEqual(
emptyLinearIssueAttributeFilter()
)
})
it('never applies another workspace filter while Linear is unresolved or disconnected', () => {
expect(selectLinearWorkspaceIssueFilter(filters, null)).toEqual(
emptyLinearIssueAttributeFilter()
)
// Why: an unresolved workspace must read as unfiltered without erasing anything.
expect(filters).toEqual({ 'workspace-a': FILTER_A, 'workspace-b': FILTER_B })
})
it('ignores inherited object keys', () => {
expect(selectLinearWorkspaceIssueFilter(filters, 'toString')).toEqual(
emptyLinearIssueAttributeFilter()
)
})
})
describe('setLinearWorkspaceIssueFilter', () => {
it('keeps workspace filters independent across A -> B -> A', () => {
let filters: Record<string, LinearIssueAttributeFilter> = {}
filters = setLinearWorkspaceIssueFilter(filters, 'workspace-a', FILTER_A)
expect(selectLinearWorkspaceIssueFilter(filters, 'workspace-a')).toEqual(FILTER_A)
// Switching to B shows B's (empty) filter without touching A's.
expect(selectLinearWorkspaceIssueFilter(filters, 'workspace-b')).toEqual(
emptyLinearIssueAttributeFilter()
)
filters = setLinearWorkspaceIssueFilter(filters, 'workspace-b', FILTER_B)
expect(selectLinearWorkspaceIssueFilter(filters, 'workspace-a')).toEqual(FILTER_A)
expect(selectLinearWorkspaceIssueFilter(filters, 'workspace-b')).toEqual(FILTER_B)
})
it('returns the same record when the canonical filter is unchanged', () => {
const filters = setLinearWorkspaceIssueFilter({}, 'workspace-a', FILTER_A)
expect(setLinearWorkspaceIssueFilter(filters, 'workspace-a', { ...FILTER_A })).toBe(filters)
// Canonical-equivalent unsorted/duplicate IDs must preserve record identity too.
expect(
setLinearWorkspaceIssueFilter(filters, 'workspace-a', {
...FILTER_A,
stateIds: ['state-a', 'state-a']
})
).toBe(filters)
})
it('removes the entry when the filter is cleared and leaves other workspaces alone', () => {
let filters = setLinearWorkspaceIssueFilter({}, 'workspace-a', FILTER_A)
filters = setLinearWorkspaceIssueFilter(filters, 'workspace-b', FILTER_B)
filters = setLinearWorkspaceIssueFilter(
filters,
'workspace-a',
emptyLinearIssueAttributeFilter()
)
expect(filters).toEqual({ 'workspace-b': FILTER_B })
})
it('refuses an unusable workspace key', () => {
const filters = { 'workspace-a': FILTER_A }
expect(setLinearWorkspaceIssueFilter(filters, '__proto__', FILTER_B)).toBe(filters)
expect(setLinearWorkspaceIssueFilter(filters, '', FILTER_B)).toBe(filters)
})
})
describe('startup sequences', () => {
const persisted = {
viewMode: 'board',
groupBy: 'status',
orderBy: 'updated',
displayProperties: ['state'],
teamPropertyTouched: true,
filtersByWorkspaceId: { 'workspace-a': FILTER_A, 'workspace-b': FILTER_B }
}
it('cold start with the workspace already resolved shows that workspace filter', () => {
const restored = resolveLinearIssueViewResumeState(persisted)
expect(selectLinearWorkspaceIssueFilter(restored.filtersByWorkspaceId, 'workspace-b')).toEqual(
FILTER_B
)
expect(restored.viewMode).toBe('board')
})
it('cold start with the workspace resolving after hydration keeps the restored filter', () => {
const restored = resolveLinearIssueViewResumeState(persisted)
// Hydration lands first with Linear still unresolved...
expect(selectLinearWorkspaceIssueFilter(restored.filtersByWorkspaceId, null)).toEqual(
emptyLinearIssueAttributeFilter()
)
// ...and the workspace resolving later needs no reset effect to surface the filter.
expect(selectLinearWorkspaceIssueFilter(restored.filtersByWorkspaceId, 'workspace-a')).toEqual(
FILTER_A
)
expect(serializeLinearIssueViewResumeState(restored)).toEqual(restored)
})
it('persists the full map when a workspace switch happens during startup', () => {
const restored = resolveLinearIssueViewResumeState(persisted)
// Linear resolves workspace-b mid-startup and the user edits its filter there.
const edited = setLinearWorkspaceIssueFilter(
restored.filtersByWorkspaceId,
'workspace-b',
filter({ priorities: [0] })
)
expect(
serializeLinearIssueViewResumeState({ ...restored, filtersByWorkspaceId: edited })
).toEqual({
...persisted,
filtersByWorkspaceId: {
'workspace-a': FILTER_A,
'workspace-b': filter({ priorities: [0] })
}
})
})
})