test(dialog): unit-test the sharing dialog

Cover the Share client and its mutation delegation, the property field
(rendering, debounced persistence, native validity, datetime), the inline
toggle field, recipient-to-model mapping, the outcome summary helper and
the share panel behavior (presets, permission toggles, recipient sync,
summary and folder-upload notes).

Assisted-by: ClaudeCode:claude-opus-4-8
Signed-off-by: skjnldsv <skjnldsv@protonmail.com>

Author: skjnldsv

lib/dialog/api/share.spec.ts

@@ -0,0 +1,199 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+import type { INode } from '@nextcloud/files'
+import type { SharingShare } from '../types/api.ts'
+import type { Share } from './share.ts'
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { SOURCE_TYPE_NODE } from '../constants.ts'
+import { createShare, getShare, searchRecipients } from './share.ts'
+import * as client from './sharing.ts'
+
+vi.mock('./sharing.ts', () => ({
+	createShare: vi.fn(),
+	getShare: vi.fn(),
+	addShareSource: vi.fn(),
+	removeShareSource: vi.fn(),
+	addShareRecipient: vi.fn(),
+	removeShareRecipient: vi.fn(),
+	updateShareRecipientSecret: vi.fn(),
+	updateShareProperty: vi.fn(),
+	updateSharePermission: vi.fn(),
+	selectSharePermissionPreset: vi.fn(),
+	updateShareState: vi.fn(),
+	searchRecipients: vi.fn(),
+	deleteShare: vi.fn(),
+}))
+
+const mocked = vi.mocked(client)
+
+/**
+ * Build a minimal share schema for testing.
+ *
+ * @param overrides Fields to override on the default schema
+ */
+function share(overrides: Partial<SharingShare> = {}): SharingShare {
+	return {
+		id: 'abc',
+		owner: { user_id: 'alice', instance: null, display_name: 'Alice', icon: { svg: '' } },
+		last_updated: 0,
+		state: 'draft',
+		sources: [],
+		recipients: [],
+		properties: [],
+		permissions: [],
+		permission_preset: null,
+		...overrides,
+	}
+}
+
+/**
+ * Obtain a Share instance wrapping the given schema, via the public factory.
+ *
+ * @param data The schema the instance should wrap
+ */
+async function makeShare(data: SharingShare = share()): Promise<Share> {
+	mocked.getShare.mockResolvedValueOnce(data)
+	return getShare(data.id)
+}
+
+beforeEach(() => {
+	vi.clearAllMocks()
+})
+
+describe('Share', () => {
+	it('createShare() wraps the created draft', async () => {
+		mocked.createShare.mockResolvedValue(share({ id: 'new' }))
+		const instance = await createShare()
+		expect(mocked.createShare).toHaveBeenCalledOnce()
+		expect(instance.id).toBe('new')
+		expect(instance.state).toBe('draft')
+	})
+
+	it('getShare() fetches an existing share', async () => {
+		mocked.getShare.mockResolvedValue(share({ id: 'x' }))
+		const instance = await getShare('x', 'secret', { password: 'p' })
+		expect(mocked.getShare).toHaveBeenCalledWith('x', 'secret', { password: 'p' })
+		expect(instance.id).toBe('x')
+	})
+
+	it('exposes the schema through getters', async () => {
+		const data = share({
+			state: 'active',
+			permission_preset: 'preset-a',
+			sources: [{ class: 'S', value: '1', display_name: 'file', icon: null }],
+		})
+		const instance = await makeShare(data)
+		expect(instance.data).toBe(data)
+		expect(instance.state).toBe('active')
+		expect(instance.permissionPreset).toBe('preset-a')
+		expect(instance.sources).toHaveLength(1)
+	})
+
+	it('mutations pass the id to the client and re-sync the data', async () => {
+		const instance = await makeShare(share({ id: 'abc' }))
+		const updated = share({ id: 'abc', state: 'active' })
+		mocked.updateShareState.mockResolvedValue(updated)
+
+		const result = await instance.setState('active')
+
+		expect(mocked.updateShareState).toHaveBeenCalledWith('abc', 'active')
+		expect(result).toBe(instance) // returns this for chaining
+		expect(instance.data).toBe(updated) // internal data replaced
+		expect(instance.state).toBe('active')
+	})
+
+	it('setProperty forwards the class and value', async () => {
+		const instance = await makeShare()
+		mocked.updateShareProperty.mockResolvedValue(share())
+		await instance.setProperty('P', 'v')
+		expect(mocked.updateShareProperty).toHaveBeenCalledWith('abc', 'P', 'v')
+	})
+
+	it('setPermission forwards the class and enabled flag', async () => {
+		const instance = await makeShare()
+		mocked.updateSharePermission.mockResolvedValue(share())
+		await instance.setPermission('C', false)
+		expect(mocked.updateSharePermission).toHaveBeenCalledWith('abc', 'C', false)
+	})
+
+	it('addSource forwards the class and value', async () => {
+		const instance = await makeShare()
+		mocked.addShareSource.mockResolvedValue(share())
+		await instance.addSource('S', '1')
+		expect(mocked.addShareSource).toHaveBeenCalledWith('abc', 'S', '1')
+	})
+
+	it('addNode maps the node to the node source type', async () => {
+		const instance = await makeShare()
+		mocked.addShareSource.mockResolvedValue(share())
+		await instance.addNode({ fileid: 42 } as unknown as INode)
+		expect(mocked.addShareSource).toHaveBeenCalledWith('abc', SOURCE_TYPE_NODE, '42')
+	})
+
+	it('removeSource forwards the class and value', async () => {
+		const instance = await makeShare()
+		mocked.removeShareSource.mockResolvedValue(share())
+		await instance.removeSource('S', '1')
+		expect(mocked.removeShareSource).toHaveBeenCalledWith('abc', 'S', '1')
+	})
+
+	it('addRecipient forwards class, value and instance', async () => {
+		const instance = await makeShare()
+		mocked.addShareRecipient.mockResolvedValue(share())
+		await instance.addRecipient('R', 'bob', 'https://remote.example')
+		expect(mocked.addShareRecipient).toHaveBeenCalledWith('abc', 'R', 'bob', 'https://remote.example')
+	})
+
+	it('removeRecipient forwards class, value and instance', async () => {
+		const instance = await makeShare()
+		mocked.removeShareRecipient.mockResolvedValue(share())
+		await instance.removeRecipient('R', 'bob')
+		expect(mocked.removeShareRecipient).toHaveBeenCalledWith('abc', 'R', 'bob', undefined)
+	})
+
+	it('setRecipientSecret forwards the secret', async () => {
+		const instance = await makeShare()
+		mocked.updateShareRecipientSecret.mockResolvedValue(share())
+		await instance.setRecipientSecret('R', 'bob', 'sEcret')
+		expect(mocked.updateShareRecipientSecret).toHaveBeenCalledWith('abc', 'R', 'bob', 'sEcret', undefined)
+	})
+
+	it('selectPreset forwards the preset class', async () => {
+		const instance = await makeShare()
+		mocked.selectSharePermissionPreset.mockResolvedValue(share())
+		await instance.selectPreset('preset-a')
+		expect(mocked.selectSharePermissionPreset).toHaveBeenCalledWith('abc', 'preset-a')
+	})
+
+	it('refresh re-fetches the share by id', async () => {
+		const instance = await makeShare(share({ id: 'abc' }))
+		const fresh = share({ id: 'abc', state: 'active' })
+		mocked.getShare.mockResolvedValueOnce(fresh)
+		await instance.refresh()
+		expect(mocked.getShare).toHaveBeenLastCalledWith('abc')
+		expect(instance.data).toBe(fresh)
+	})
+
+	it('activate() sets the state to active', async () => {
+		const instance = await makeShare()
+		mocked.updateShareState.mockResolvedValue(share({ state: 'active' }))
+		await instance.activate()
+		expect(mocked.updateShareState).toHaveBeenCalledWith('abc', 'active')
+	})
+
+	it('delete() removes the share and returns nothing', async () => {
+		const instance = await makeShare()
+		mocked.deleteShare.mockResolvedValue()
+		await expect(instance.delete()).resolves.toBeUndefined()
+		expect(mocked.deleteShare).toHaveBeenCalledWith('abc')
+	})
+
+	it('searchRecipients delegates to the client', async () => {
+		mocked.searchRecipients.mockResolvedValue([])
+		await searchRecipients('bob', 'UserType', 5, 2)
+		expect(mocked.searchRecipients).toHaveBeenCalledWith('bob', 'UserType', 5, 2)
+	})
+})

lib/dialog/components/InlineToggleField.spec.ts

@@ -0,0 +1,117 @@
+/**
+ * SPDX-FileCopyrightText: 2026 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+import type { VueWrapper } from '@vue/test-utils'
+
+import { mount } from '@vue/test-utils'
+import { describe, expect, it } from 'vitest'
+import { h, nextTick } from 'vue'
+import InlineToggleField from './InlineToggleField.vue'
+
+const INACTIVE = '.inline-toggle-field__slot--inactive'
+const SLOT = '.inline-toggle-field__slot'
+const TOGGLE_INPUT = '.inline-toggle-field__toggle input'
+
+/**
+ * Mount with a focusable input in the default slot.
+ *
+ * @param props Component props
+ */
+function mountField(props: { modelValue: boolean, label?: string, longText?: boolean }): VueWrapper {
+	return mount(InlineToggleField, {
+		props: { label: 'Note', ...props },
+		slots: {
+			default: (slotProps: { inputId: string }) => h('input', { id: slotProps.inputId, class: 'slot-input' }),
+		},
+		attachTo: document.body,
+	})
+}
+
+describe('InlineToggleField', () => {
+	it('renders the slot content and the toggle switch', () => {
+		const wrapper = mountField({ modelValue: true })
+		expect(wrapper.find('.slot-input').exists()).toBe(true)
+		expect(wrapper.find(TOGGLE_INPUT).exists()).toBe(true)
+	})
+
+	it('marks the slot inactive when disabled', () => {
+		const wrapper = mountField({ modelValue: false })
+		expect(wrapper.find(INACTIVE).exists()).toBe(true)
+	})
+
+	it('does not mark the slot inactive when enabled', () => {
+		const wrapper = mountField({ modelValue: true })
+		expect(wrapper.find(INACTIVE).exists()).toBe(false)
+	})
+
+	it('emits update:modelValue(true) when toggled on', async () => {
+		const wrapper = mountField({ modelValue: false })
+		await wrapper.find(TOGGLE_INPUT).setValue(true)
+		expect(wrapper.emitted('update:modelValue')?.[0]).toEqual([true])
+	})
+
+	it('emits update:modelValue(false) when toggled off', async () => {
+		const wrapper = mountField({ modelValue: true })
+		await wrapper.find(TOGGLE_INPUT).setValue(false)
+		expect(wrapper.emitted('update:modelValue')?.[0]).toEqual([false])
+	})
+
+	it('enables by clicking the inactive slot', async () => {
+		const wrapper = mountField({ modelValue: false })
+		await wrapper.find(SLOT).trigger('click')
+		expect(wrapper.emitted('update:modelValue')?.[0]).toEqual([true])
+	})
+
+	it('does not emit when clicking the active slot', async () => {
+		const wrapper = mountField({ modelValue: true })
+		await wrapper.find(SLOT).trigger('click')
+		expect(wrapper.emitted('update:modelValue')).toBeUndefined()
+	})
+
+	it('enables when clicking a field element inside the inactive slot', async () => {
+		const wrapper = mountField({ modelValue: false })
+		// A click on the field bubbles to the slot handler and enables it
+		await wrapper.find('.slot-input').trigger('click')
+		expect(wrapper.emitted('update:modelValue')?.[0]).toEqual([true])
+	})
+
+	// Note: with a *disabled* inner field, the click reaching the slot relies on
+	// the `pointer-events: none` reroute, which happy-dom does not simulate (a
+	// disabled control fires no click). That path is covered by browser tests.
+
+	it('does not emit when clicking a field element inside the active slot', async () => {
+		const wrapper = mountField({ modelValue: true })
+		await wrapper.find('.slot-input').trigger('click')
+		expect(wrapper.emitted('update:modelValue')).toBeUndefined()
+	})
+
+	it('focuses the first focusable slot element after enabling', async () => {
+		const wrapper = mountField({ modelValue: false })
+		await wrapper.find(TOGGLE_INPUT).setValue(true)
+		await nextTick()
+		expect(document.activeElement).toBe(wrapper.find('.slot-input').element)
+	})
+
+	it('does not throw when enabling with no focusable slot element', async () => {
+		const wrapper = mount(InlineToggleField, {
+			props: { label: 'Note', modelValue: false },
+			slots: { default: () => h('span', 'just text') },
+			attachTo: document.body,
+		})
+		await expect(wrapper.find(TOGGLE_INPUT).setValue(true)).resolves.not.toThrow()
+	})
+
+	it('adds the long-text class on the toggle when longText is set', () => {
+		const wrapper = mountField({ modelValue: true, longText: true })
+		expect(wrapper.find('.inline-toggle-field__toggle--long-text').exists()).toBe(true)
+	})
+
+	it('exposes the group aria-label and wires the slot input id', () => {
+		const wrapper = mountField({ modelValue: true, label: 'Expiration' })
+		expect(wrapper.find('[role="group"]').attributes('aria-label')).toBe('Expiration')
+		const slotId = wrapper.find('.slot-input').attributes('id')
+		expect(slotId).toBeTruthy()
+		expect(wrapper.find(TOGGLE_INPUT).attributes('aria-controls')).toBe(slotId)
+	})
+})