From 5e0c77fecc0c6d6cac28af2c5a54faf636862dc9 Mon Sep 17 00:00:00 2001
From: Grigory Vodyanov <scratchx@gmx.com>
Date: Sun, 12 Jul 2026 23:40:16 +0200
Subject: [PATCH] fix: merging

Signed-off-by: Grigory Vodyanov <scratchx@gmx.com>
---
 src/components/ContactsList.vue              |  17 +-
 src/components/ContactsList/Merging.vue      | 238 +++++++++----------
 src/utils/mergeContacts.ts                   | 122 ++++++++++
 tests/javascript/utils/mergeContacts.test.ts | 175 ++++++++++++++
 4 files changed, 427 insertions(+), 125 deletions(-)
 create mode 100644 src/utils/mergeContacts.ts
 create mode 100644 tests/javascript/utils/mergeContacts.test.ts

diff --git a/src/components/ContactsList.vue b/src/components/ContactsList.vue
index bf43f2258a..f3fa13f175 100644
--- a/src/components/ContactsList.vue
+++ b/src/components/ContactsList.vue
@@ -480,11 +480,18 @@ export default {
 		},
 
 		async finishContactMerging(mergedContact) {
-			// After merging, we need to update the contact in the store
-			await this.$store.dispatch('fetchFullContact', { contact: mergedContact, forceReFetch: true })
-
-			this.unselectAllMultiSelected()
-			this.isMerging = false
+			try {
+				// After merging, we need to update the contact in the store
+				await this.$store.dispatch('fetchFullContact', { contact: mergedContact, forceReFetch: true })
+			} catch (error) {
+				// The merge itself already succeeded on the server, so we must
+				// not leave the dialog stuck in a loading state if refreshing
+				// the merged contact fails.
+				console.error('Could not refresh the merged contact', error)
+			} finally {
+				this.unselectAllMultiSelected()
+				this.isMerging = false
+			}
 
 			await this.$router.push({
 				name: 'root',
diff --git a/src/components/ContactsList/Merging.vue b/src/components/ContactsList/Merging.vue
index 8d2a75aaef..59cdcd6e6e 100644
--- a/src/components/ContactsList/Merging.vue
+++ b/src/components/ContactsList/Merging.vue
@@ -23,6 +23,11 @@
 			type="warning"
 			:text="t('contacts', 'The selected contacts have conflicting information. Choose which information to keep')" />
 
+		<NcNoteCard
+			v-else-if="chosenAddressBook === null"
+			type="info"
+			:text="t('contacts', 'Select the address book to merge the contacts into')" />
+
 		<NcNoteCard
 			v-else
 			type="success"
@@ -144,7 +149,7 @@
 		</div>
 
 		<div class="merging__actions">
-			<NcButton :disabled="conflictsToResolve !== 0" variant="secondary" @click="mergeContacts">
+			<NcButton :disabled="!canMerge || isLoading" variant="secondary" @click="mergeContacts">
 				{{ t('contacts', 'Merge contacts') }}
 				<template #icon>
 					<IconSetMerge v-if="!isLoading" :size="20" />
@@ -156,6 +161,7 @@
 </template>
 
 <script>
+import { showError } from '@nextcloud/dialogs'
 import { NcButton, NcCheckboxRadioSwitch, NcLoadingIcon, NcNoteCard, NcSelect } from '@nextcloud/vue'
 import ICAL from 'ical.js'
 import mitt from 'mitt'
@@ -167,6 +173,7 @@ import IconDomain from 'vue-material-design-icons/Domain.vue'
 import IconSetMerge from 'vue-material-design-icons/SetMerge.vue'
 import ContactDetailsProperty from '../ContactDetails/ContactDetailsProperty.vue'
 import rfcProps from '../../models/rfcProps.js'
+import { comparePropertyLists, getPropertyValue, isPropertyListEmpty } from '../../utils/mergeContacts.ts'
 
 export default {
 	name: 'Merging',
@@ -193,6 +200,8 @@ export default {
 		},
 	},
 
+	emits: ['finished'],
+
 	data() {
 		return {
 			bus: mitt(),
@@ -246,12 +255,13 @@ export default {
 		usedProperties() {
 			const allKeys = this.dividedProperties.flatMap((map) => Object.keys(map))
 			return [...new Set(allKeys)].filter((key) => {
-				const valA = this.dividedProperties[0][key] ? this.dividedProperties[0][key].map((value) => this.getPropertyValue(value)) : []
-				const valB = this.dividedProperties[1][key] ? this.dividedProperties[1][key].map((value) => this.getPropertyValue(value)) : []
-				return (
-					(!valA.every((val) => val === null || val === undefined || val === ''))
-					|| (!valB.every((val) => val === null || val === undefined || val === ''))
-				)
+				// Only consider a property "used" if at least one of the contacts
+				// holds a non-empty value for it. This correctly handles structured
+				// and multi-value properties (e.g. an empty "ADR:;;;;;;" or an empty
+				// "CATEGORIES:") which would otherwise show up as phantom rows.
+				const isAEmpty = isPropertyListEmpty(this.dividedProperties[0][key])
+				const isBEmpty = isPropertyListEmpty(this.dividedProperties[1][key])
+				return !(isAEmpty && isBEmpty)
 			})
 		},
 
@@ -259,52 +269,38 @@ export default {
 			const conflictInformation = {}
 
 			this.usedProperties.forEach((property) => {
-				if ((this.dividedProperties[0][property] ?? []).every((val) => this.checkIfPropertyEmpty(val))) {
+				const type = comparePropertyLists(
+					this.dividedProperties[0][property],
+					this.dividedProperties[1][property],
+				)
+
+				if (type === 'onlyInSecond') {
 					conflictInformation[property] = {
-						type: 'onlyInSecond',
-						value: this.dividedProperties[1][property].map((val) => this.getPropertyValue(val)),
+						type,
+						value: this.dividedProperties[1][property].map((val) => getPropertyValue(val)),
 					}
-
-					return
-				}
-
-				if ((this.dividedProperties[1][property] ?? []).every((val) => this.checkIfPropertyEmpty(val))) {
+				} else if (type === 'onlyInFirst') {
 					conflictInformation[property] = {
-						type: 'onlyInFirst',
-						value: this.dividedProperties[0][property].map((val) => this.getPropertyValue(val)),
+						type,
+						value: this.dividedProperties[0][property].map((val) => getPropertyValue(val)),
 					}
-
-					return
-				}
-
-				const equalEvery = (a, b) => a.length === b.length && a.every((v, i) => v === b[i])
-
-				if (
-					equalEvery(
-						(this.dividedProperties[0][property] ?? []).map((val) => this.getPropertyValue(val)),
-						(this.dividedProperties[1][property] ?? []).map((val) => this.getPropertyValue(val)),
-					)
-				) {
+				} else if (type === 'equal') {
 					conflictInformation[property] = {
-						type: 'equal',
-						value: this.dividedProperties[0][property].map((val) => this.getPropertyValue(val)),
+						type,
+						value: this.dividedProperties[0][property].map((val) => getPropertyValue(val)),
 					}
-
-					return
-				}
-
-				if (rfcProps.properties[property]?.multiple === true) {
+				} else if (rfcProps.properties[property]?.multiple === true) {
+					// A property that can hold several values (e.g. tel, email):
+					// let the user pick any combination of the two sides.
 					conflictInformation[property] = {
 						type: 'conflictWithMultipleValues',
 						value: null,
 					}
-
-					return
-				}
-
-				conflictInformation[property] = {
-					type: 'conflict',
-					value: null,
+				} else {
+					conflictInformation[property] = {
+						type: 'conflict',
+						value: null,
+					}
 				}
 			})
 
@@ -326,6 +322,16 @@ export default {
 				],
 			}
 		},
+
+		/**
+		 * Whether the contacts can be merged: all field conflicts are resolved
+		 * and a target address book has been chosen.
+		 *
+		 * @return {boolean}
+		 */
+		canMerge() {
+			return this.conflictsToResolve === 0 && this.chosenAddressBook !== null
+		},
 	},
 
 	mounted() {
@@ -451,44 +457,9 @@ export default {
 				}
 			})
 
-			if (this.chosenAddressBook === null) {
-				conflictsCount++
-			}
-
 			this.conflictsToResolve = conflictsCount
 		},
 
-		getPropertyValue(property) {
-			if (!property) {
-				return null
-			}
-			if (property.isMultiValue) {
-				// differences between values types :x;x;x;x;x and x,x,x,x,x
-				return property.isStructuredValue
-					? property.getValues()[0]
-					: property.getValues()
-			}
-			return property.getFirstValue()
-		},
-
-		checkIfPropertyEmpty(property) {
-			if (property === undefined) {
-				return true
-			}
-
-			const value = this.getPropertyValue(property)
-
-			if (value === '' || value === null || (Array.isArray(value) && value.length === 0)) {
-				return true
-			}
-
-			if (Array.isArray(value)) {
-				return value.every((v) => v === '' || v === undefined)
-			}
-
-			return false
-		},
-
 		sortUsedProperties() {
 			// the properties where this.conflictInformation[property].type === 'conflict' should have priority
 			return this.usedProperties.sort((a, b) => {
@@ -506,60 +477,87 @@ export default {
 		},
 
 		async mergeContacts() {
+			if (this.isLoading || !this.canMerge) {
+				return
+			}
+
 			this.isLoading = true
-			const contactToSave = this.contactsList[0]
 
-			const finalProperties = {}
+			try {
+				const contactToSave = this.contactsList[0]
 
-			this.usedProperties.forEach((property) => {
-				if (this.conflictInformation[property]?.type === 'conflict') {
-					const resolvedVersion = this.resolvedConflicts.get(property)
-					if (resolvedVersion !== undefined) {
-						finalProperties[property] = [this.dividedProperties[resolvedVersion][property]]
+				const finalProperties = {}
+
+				this.usedProperties.forEach((property) => {
+					if (this.conflictInformation[property]?.type === 'conflict') {
+						const resolvedVersion = this.resolvedConflicts.get(property)
+						if (resolvedVersion !== undefined) {
+							finalProperties[property] = [this.dividedProperties[resolvedVersion][property]]
+						}
+					} else if (this.conflictInformation[property]?.type === 'conflictWithMultipleValues') {
+						const resolvedVersions = this.resolvedConflicts.get(property)
+						if (resolvedVersions?.size) {
+							finalProperties[property] = Array.from(resolvedVersions).map((version) => this.dividedProperties[version][property])
+						}
+					} else if (this.conflictInformation[property]?.type === 'onlyInSecond') {
+						finalProperties[property] = [this.dividedProperties[1][property]]
+					} else {
+						finalProperties[property] = [this.dividedProperties[0][property]]
 					}
-				} else if (this.conflictInformation[property]?.type === 'conflictWithMultipleValues') {
-					const resolvedVersions = this.resolvedConflicts.get(property)
-					if (resolvedVersions?.size) {
-						finalProperties[property] = Array.from(resolvedVersions).map((version) => this.dividedProperties[version][property])
+				})
+
+				this.usedProperties.forEach((name) => {
+					if (finalProperties[name] !== undefined && finalProperties[name].length > 0) {
+						const properties = finalProperties[name].flat().filter((property) => property !== null && property !== undefined)
+
+						properties.forEach((property) => {
+							// Get the actual property name (for lifeEvents group, properties have their real names like 'bday')
+							const actualName = property.name
+
+							// Remove any existing property with this name from the target vCard
+							const existingProps = contactToSave.vCard.getAllProperties(actualName)
+							existingProps.forEach((prop) => contactToSave.vCard.removeProperty(prop))
+						})
+
+						// Now add all the selected properties
+						properties.forEach((property) => {
+							// Deep clone the jCal data to avoid reference issues with complex types like dates
+							const clonedJCal = JSON.parse(JSON.stringify(property.jCal))
+							const clonedProperty = new ICAL.Property(clonedJCal)
+							contactToSave.vCard.addProperty(clonedProperty)
+						})
 					}
-				} else if (this.conflictInformation[property]?.type === 'onlyInSecond') {
-					finalProperties[property] = [this.dividedProperties[1][property]]
-				} else {
-					finalProperties[property] = [this.dividedProperties[0][property]]
-				}
-			})
+				})
 
-			this.usedProperties.forEach((name) => {
-				if (finalProperties[name] !== undefined && finalProperties[name].length > 0) {
-					const properties = finalProperties[name].flat().filter((property) => property !== null && property !== undefined)
+				contactToSave.groups = this.selectedGroups
 
-					properties.forEach((property) => {
-						// Get the actual property name (for lifeEvents group, properties have their real names like 'bday')
-						const actualName = property.name
+				const targetAddressbook = this.contactsList[this.chosenAddressBook.id].addressbook
 
-						// Remove any existing property with this name from the target vCard
-						const existingProps = contactToSave.vCard.getAllProperties(actualName)
-						existingProps.forEach((prop) => contactToSave.vCard.removeProperty(prop))
-					})
+				// Persist the merged data on the surviving contact. It still lives
+				// in its original address book at this point.
+				await this.$store.dispatch('updateContact', contactToSave)
+
+				// Remove the contact that was merged into the surviving one.
+				await this.$store.dispatch('deleteContact', { contact: this.contactsList[1] })
 
-					// Now add all the selected properties
-					properties.forEach((property) => {
-						// Deep clone the jCal data to avoid reference issues with complex types like dates
-						const clonedJCal = JSON.parse(JSON.stringify(property.jCal))
-						const clonedProperty = new ICAL.Property(clonedJCal)
-						contactToSave.vCard.addProperty(clonedProperty)
+				// If the user chose a different address book, perform a proper
+				// move so the contact is actually relocated on the server and the
+				// store stays consistent (a plain addressbook reassignment would
+				// only change the key and silently desync the store).
+				if (contactToSave.addressbook.id !== targetAddressbook.id) {
+					await this.$store.dispatch('moveContactToAddressbook', {
+						contact: contactToSave,
+						addressbook: targetAddressbook,
 					})
 				}
-			})
-
-			contactToSave.groups = this.selectedGroups
-			contactToSave.addressbook = this.contactsList[this.chosenAddressBook.id].addressbook
 
-			await this.$store.dispatch('updateContact', contactToSave)
-
-			await this.$store.dispatch('deleteContact', { contact: this.contactsList[1] })
-
-			this.$emit('finished', contactToSave)
+				this.$emit('finished', contactToSave)
+			} catch (error) {
+				console.error('Could not merge the contacts', error)
+				showError(this.t('contacts', 'Could not merge the contacts'))
+			} finally {
+				this.isLoading = false
+			}
 		},
 	},
 }
diff --git a/src/utils/mergeContacts.ts b/src/utils/mergeContacts.ts
new file mode 100644
index 0000000000..6468dfadea
--- /dev/null
+++ b/src/utils/mergeContacts.ts
@@ -0,0 +1,122 @@
+/**
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+/**
+ * The subset of the ICAL.Property API used when merging contacts.
+ */
+export interface MergeableProperty {
+	isMultiValue: boolean
+	isStructuredValue: boolean
+	getValues(): unknown[]
+	getFirstValue(): unknown
+}
+
+type MaybeProperty = MergeableProperty | null | undefined
+
+/**
+ * How the two lists of a given property differ between the merged contacts.
+ */
+export type ConflictType = 'onlyInSecond' | 'onlyInFirst' | 'equal' | 'conflict'
+
+/**
+ * Extract a comparable value from an ICAL property.
+ *
+ * Structured multi-value properties (e.g. ADR) return their first (array)
+ * value, plain multi-value properties (e.g. NICKNAME) return the whole array
+ * of values and single-value properties return their scalar value.
+ *
+ * @param property an ICAL.Property (or null/undefined)
+ */
+export function getPropertyValue(property: MaybeProperty): unknown {
+	if (!property) {
+		return null
+	}
+	if (property.isMultiValue) {
+		// differences between values types :x;x;x;x;x and x,x,x,x,x
+		return property.isStructuredValue
+			? property.getValues()[0]
+			: property.getValues()
+	}
+	return property.getFirstValue()
+}
+
+/**
+ * Deeply compare two property values.
+ *
+ * getPropertyValue may return either a scalar or an array (structured or
+ * multi-value property). Comparing arrays with `===` always yields false
+ * since they are distinct references, which previously flagged identical
+ * multi-value properties (e.g. NICKNAME) as conflicts. This compares by
+ * value instead.
+ *
+ * @param a the first value
+ * @param b the second value
+ */
+export function valuesEqual(a: unknown, b: unknown): boolean {
+	if (Array.isArray(a) && Array.isArray(b)) {
+		return a.length === b.length && a.every((value, index) => valuesEqual(value, b[index]))
+	}
+	return a === b
+}
+
+/**
+ * Whether a single property holds no meaningful value.
+ *
+ * @param property an ICAL.Property (or null/undefined)
+ */
+export function isPropertyEmpty(property: MaybeProperty): boolean {
+	if (property === undefined || property === null) {
+		return true
+	}
+
+	const value = getPropertyValue(property)
+
+	if (value === '' || value === null || (Array.isArray(value) && value.length === 0)) {
+		return true
+	}
+
+	if (Array.isArray(value)) {
+		return value.every((entry) => entry === '' || entry === undefined)
+	}
+
+	return false
+}
+
+/**
+ * Whether every property in the list is empty. An empty or missing list
+ * counts as empty.
+ *
+ * @param properties a list of ICAL.Property instances
+ */
+export function isPropertyListEmpty(properties: MaybeProperty[] | null | undefined): boolean {
+	return (properties ?? []).every((property) => isPropertyEmpty(property))
+}
+
+/**
+ * Classify how the two lists of a given property differ between contacts.
+ *
+ * @param propertiesA the property instances of the first contact
+ * @param propertiesB the property instances of the second contact
+ */
+export function comparePropertyLists(
+	propertiesA: MaybeProperty[] | null | undefined,
+	propertiesB: MaybeProperty[] | null | undefined,
+): ConflictType {
+	if (isPropertyListEmpty(propertiesA)) {
+		return 'onlyInSecond'
+	}
+	if (isPropertyListEmpty(propertiesB)) {
+		return 'onlyInFirst'
+	}
+
+	const valuesA = (propertiesA ?? []).map(getPropertyValue)
+	const valuesB = (propertiesB ?? []).map(getPropertyValue)
+
+	if (valuesA.length === valuesB.length && valuesA.every((value, index) => valuesEqual(value, valuesB[index]))) {
+		return 'equal'
+	}
+
+	return 'conflict'
+}
diff --git a/tests/javascript/utils/mergeContacts.test.ts b/tests/javascript/utils/mergeContacts.test.ts
new file mode 100644
index 0000000000..d1663b56da
--- /dev/null
+++ b/tests/javascript/utils/mergeContacts.test.ts
@@ -0,0 +1,175 @@
+/**
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import * as ICALModule from 'ical.js'
+import {
+	comparePropertyLists,
+	getPropertyValue,
+	isPropertyEmpty,
+	isPropertyListEmpty,
+	valuesEqual,
+} from '../../../src/utils/mergeContacts.ts'
+
+// ical.js is published as an ESM default export but resolves to a CommonJS
+// module under ts-jest; support both shapes.
+const ICAL = ('default' in ICALModule ? ICALModule.default : ICALModule) as typeof ICALModule.default
+
+/**
+ * Build a vCard string from its body lines.
+ *
+ * @param lines the properties of the contact
+ */
+function vcard(lines: string[]): string {
+	return ['BEGIN:VCARD', 'VERSION:3.0', 'UID:test', ...lines, 'END:VCARD'].join('\r\n')
+}
+
+/**
+ * Return the ICAL properties of a given name from a vCard body.
+ *
+ * @param lines the properties of the contact
+ * @param name the property name to extract
+ */
+function propertiesOf(lines: string[], name: string) {
+	const component = new ICAL.Component(ICAL.parse(vcard(lines)))
+	return component.getAllProperties(name)
+}
+
+describe('mergeContacts - valuesEqual', () => {
+	test('compares scalars', () => {
+		expect(valuesEqual('a', 'a')).toBe(true)
+		expect(valuesEqual('a', 'b')).toBe(false)
+		expect(valuesEqual('', '')).toBe(true)
+		expect(valuesEqual(null, null)).toBe(true)
+	})
+
+	test('compares arrays by value, not by reference', () => {
+		// The original bug: two distinct arrays with identical contents
+		// compared with === always returned false.
+		expect(valuesEqual(['nick'], ['nick'])).toBe(true)
+		expect(valuesEqual(['a', 'b'], ['a', 'b'])).toBe(true)
+		expect(valuesEqual(['a', 'b'], ['b', 'a'])).toBe(false)
+		expect(valuesEqual(['a'], ['a', 'b'])).toBe(false)
+	})
+
+	test('handles nested arrays', () => {
+		expect(valuesEqual([['a', 'b']], [['a', 'b']])).toBe(true)
+		expect(valuesEqual([['a', 'b']], [['a', 'c']])).toBe(false)
+	})
+})
+
+describe('mergeContacts - getPropertyValue', () => {
+	test('returns null for a missing property', () => {
+		expect(getPropertyValue(undefined)).toBe(null)
+		expect(getPropertyValue(null)).toBe(null)
+	})
+
+	test('returns a scalar for single-value properties', () => {
+		const [fn] = propertiesOf(['FN:John'], 'fn')
+		expect(getPropertyValue(fn)).toBe('John')
+	})
+
+	test('returns an array for plain multi-value properties (nickname)', () => {
+		const [nickname] = propertiesOf(['NICKNAME:nick'], 'nickname')
+		expect(getPropertyValue(nickname)).toEqual(['nick'])
+	})
+
+	test('returns the first (array) value for structured properties (adr)', () => {
+		const [adr] = propertiesOf(['ADR;TYPE=HOME:;;Main Street;City;;;'], 'adr')
+		expect(getPropertyValue(adr)).toEqual(['', '', 'Main Street', 'City', '', '', ''])
+	})
+})
+
+describe('mergeContacts - isPropertyEmpty / isPropertyListEmpty', () => {
+	test('an absent property is empty', () => {
+		expect(isPropertyEmpty(undefined)).toBe(true)
+		expect(isPropertyEmpty(null)).toBe(true)
+	})
+
+	test('an empty structured property (ADR:;;;;;;) is empty', () => {
+		const [adr] = propertiesOf(['ADR;TYPE=HOME:;;;;;;'], 'adr')
+		expect(isPropertyEmpty(adr)).toBe(true)
+	})
+
+	test('an empty multi-value property (CATEGORIES:) is empty', () => {
+		const [categories] = propertiesOf(['CATEGORIES:'], 'categories')
+		expect(isPropertyEmpty(categories)).toBe(true)
+	})
+
+	test('a filled property is not empty', () => {
+		const [fn] = propertiesOf(['FN:John'], 'fn')
+		expect(isPropertyEmpty(fn)).toBe(false)
+		const [adr] = propertiesOf(['ADR;TYPE=HOME:;;Main Street;;;;'], 'adr')
+		expect(isPropertyEmpty(adr)).toBe(false)
+	})
+
+	test('an empty or missing list counts as empty', () => {
+		expect(isPropertyListEmpty([])).toBe(true)
+		expect(isPropertyListEmpty(undefined)).toBe(true)
+		expect(isPropertyListEmpty(propertiesOf(['ADR;TYPE=HOME:;;;;;;'], 'adr'))).toBe(true)
+	})
+
+	test('a list with at least one filled property is not empty', () => {
+		expect(isPropertyListEmpty(propertiesOf(['FN:John'], 'fn'))).toBe(false)
+	})
+})
+
+describe('mergeContacts - comparePropertyLists', () => {
+	test('identical single values are equal', () => {
+		expect(comparePropertyLists(
+			propertiesOf(['FN:John'], 'fn'),
+			propertiesOf(['FN:John'], 'fn'),
+		)).toBe('equal')
+	})
+
+	test('identical nicknames are equal (regression: phantom conflict)', () => {
+		expect(comparePropertyLists(
+			propertiesOf(['NICKNAME:nick'], 'nickname'),
+			propertiesOf(['NICKNAME:nick'], 'nickname'),
+		)).toBe('equal')
+	})
+
+	test('identical phone numbers are equal', () => {
+		expect(comparePropertyLists(
+			propertiesOf(['TEL;TYPE=CELL:+49 211 91378708'], 'tel'),
+			propertiesOf(['TEL;TYPE=CELL:+49 211 91378708'], 'tel'),
+		)).toBe('equal')
+	})
+
+	test('different values conflict', () => {
+		expect(comparePropertyLists(
+			propertiesOf(['FN:John'], 'fn'),
+			propertiesOf(['FN:Jane'], 'fn'),
+		)).toBe('conflict')
+	})
+
+	test('different nicknames conflict', () => {
+		expect(comparePropertyLists(
+			propertiesOf(['NICKNAME:nickA'], 'nickname'),
+			propertiesOf(['NICKNAME:nickB'], 'nickname'),
+		)).toBe('conflict')
+	})
+
+	test('a value present only in the first contact', () => {
+		expect(comparePropertyLists(
+			propertiesOf(['NICKNAME:nick'], 'nickname'),
+			propertiesOf([], 'nickname'),
+		)).toBe('onlyInFirst')
+	})
+
+	test('a value present only in the second contact', () => {
+		expect(comparePropertyLists(
+			propertiesOf([], 'title'),
+			propertiesOf(['TITLE:Dr'], 'title'),
+		)).toBe('onlyInSecond')
+	})
+
+	test('an empty value on one side is treated as "only in" the other', () => {
+		// An empty ADR on one side should not count as a real value.
+		expect(comparePropertyLists(
+			propertiesOf(['ADR;TYPE=HOME:;;;;;;'], 'adr'),
+			propertiesOf(['ADR;TYPE=HOME:;;Main Street;City;;;'], 'adr'),
+		)).toBe('onlyInSecond')
+	})
+})