Backtestsvuerun-20261009-161443#10505
Clearing select's value in change handler behaviour changed since 3.4.15 via webdriver
The merged fix was judged better than our patch.
In this judgment, Patch A = our agent, Patch B = the merged fix.
Both patches fix the same root cause. Since the select performance change, `updated` skips `setSelected` whenever `_assigning` is true. So if the model changes again in the same tick (for example, reset to null in an `@change` handler), the DOM is never resynced. Patch A records the assigned value and resyncs when `toRaw(value) !== toRaw(_assignedValue)`. That covers the reported case: a single select reset to null, or a multiple select reassigned to a new array. However, it relies on reference identity. If the handler mutates the emitted array or Set in place (for example `value.pop()`, `value.length = 0` or `set.delete(x)`), the reference is unchanged. A then still skips the resync and the DOM stays stale. That is the same class of bug the issue describes, so A only partly closes it. A's two tests are reasonable and would fail before the fix. Patch B stores a snapshot of the pending value, copying `selectedVal` for array models. In `updated` it compares that snapshot to the current model by content: `looseEqual` for single and Array values, and a membership check for Sets. It also detects a `multiple` flip, clears the pending state after the first `updated`, and uses try/finally plus an identity check so a throwing assigner cannot leave stale state. As a result it handles both reset-by-reassignment and reset-by-mutation, while still skipping redundant DOM writes when nothing changed, which preserves the purpose of the original performance optimization. B's tests are broader and meaningful. They include the issue's change-handler reset, in-place Array and Set mutation, Set override, duplicate option values, and write-counting tests confirming no extra `selected` writes in the common case. B is more code, but it is coherent and low-risk, and the extra comparison helper is clearly named. On correctness, B is more robust within the issue's scenario space, so B wins.
The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.
Solve
4m 35s
Wall-clock time in the container
Full test suite
No new failures
705 passed · 1 skipped · 706 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
109vs 345 merged
Changed lines, ours vs merged
The issue
View on GitHubVue version
3.4.21
Link to minimal reproduction
Steps to reproduce
👋 sorry I can only reproduce this myself when acting on chrome with webdriver, but I have narrowed it down a lot
the basic premise is we have a strange select that clears its value on change, exampled in the repo link
The bug occurs when _webdriver_ clicks the select and clicks one of the options within the value does not get cleared afterwards. If I click in the page myself it clears properly.
What is expected?
The value of the select afterwards should be null
What is actually happening?
it is whatever was selected last, ie 0 or 1
System Info
System:
OS: Linux 5.15 Ubuntu 20.04.6 LTS (Focal Fossa)
CPU: (32) x64 AMD Ryzen 9 5950X 16-Core Processor
Memory: 55.80 GB / 88.39 GB
Container: Yes
Shell: 5.0.17 - /bin/bash
Binaries:
Node: 18.16.1 - ~/.nvm/versions/node/v18.16.1/bin/node
npm: 9.5.1 - ~/.nvm/versions/node/v18.16.1/bin/npm
Browsers:
Chrome: 122.0.6261.94
Any additional comments?
I have bisected the releases and found that this first happens from 3.4.15. I suspect the change is related to the select performance improvement https://github.com/vuejs/core/commit/2ffb956efe692da059f4895669084c5278871351
further i notice the commit introduces and _assigning field which changes the behaviour until the next tick. and wrapping the clearing call in nextTick works as a workaround in my instance.
nextTick(() => { selection.value = null })
I suspect the issue relates to the fact that webdriver submits selection events in a slightly unusual manner. However I think that shouldn't mean this broke but it has
The two patches
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 590c0d7df..5250edaaf 100644@@ -1009,6 +1009,93 @@ describe('vModel', () => { expect(bar.selected).toEqual(true) }) + it('should sync select DOM when model is reset in change handler', async () => {+ const component = defineComponent({+ data() {+ return { value: null as string | null }+ },+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': setValue.bind(this),+ onChange: () => {+ this.value = null+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const input = root.querySelector('select')+ const foo = root.querySelector('option[value=foo]')+ const bar = root.querySelector('option[value=bar]')+ const data = root._vnode.component.data++ foo.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(data.value).toEqual(null)+ expect(input.selectedIndex).toEqual(-1)+ expect(foo.selected).toEqual(false)+ expect(bar.selected).toEqual(false)++ bar.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(data.value).toEqual(null)+ expect(input.selectedIndex).toEqual(-1)+ expect(foo.selected).toEqual(false)+ expect(bar.selected).toEqual(false)+ })++ it('should sync multiple select DOM when model is reset in change handler', async () => {+ const component = defineComponent({+ data() {+ return { value: [] as string[] }+ },+ render() {+ return [+ withVModel(+ h(+ 'select',+ {+ multiple: true,+ 'onUpdate:modelValue': setValue.bind(this),+ onChange: () => {+ this.value = []+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ ),+ ]+ },+ })+ render(h(component), root)++ const input = root.querySelector('select')+ const foo = root.querySelector('option[value=foo]')+ const bar = root.querySelector('option[value=bar]')+ const data = root._vnode.component.data++ foo.selected = true+ bar.selected = true+ triggerEvent('change', input)+ await nextTick()+ expect(data.value).toMatchObject([])+ expect(foo.selected).toEqual(false)+ expect(bar.selected).toEqual(false)+ })+ it('multiple select (model is Array)', async () => { const component = defineComponent({ data() {packages/runtime-dom/src/directives/vModel.tsindex eeb248f28..ff7f1d1a6 100644@@ -4,6 +4,7 @@ import { type ObjectDirective, type VNode, nextTick,+ toRaw, warn, } from '@vue/runtime-core' import { addEventListener } from '../modules/events'@@ -45,6 +46,7 @@ type ModelDirective<T, Modifiers extends string = string> = ObjectDirective< [assignKey]: AssignerFn [initialValueKey]?: string _assigning?: boolean+ _assignedValue?: any }, any, Modifiers@@ -240,16 +242,17 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { .map((o: HTMLOptionElement) => number ? looseToNumber(getValue(o)) : getValue(o), )- el[assignKey](- el.multiple- ? isSet((el as any)._modelValue)- ? new Set(selectedVal)- : selectedVal- : selectedVal[0],- )+ const assignedValue = el.multiple+ ? isSet((el as any)._modelValue)+ ? new Set(selectedVal)+ : selectedVal+ : selectedVal[0]+ el[assignKey](assignedValue) el._assigning = true+ el._assignedValue = assignedValue nextTick(() => { el._assigning = false+ el._assignedValue = undefined }) }) el[assignKey] = getModelAssigner(vnode)@@ -264,7 +267,10 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { el[assignKey] = getModelAssigner(vnode) }, updated(el, { value }) {- if (!el._assigning) {+ // the DOM already reflects the value assigned by the change listener, so+ // syncing can be skipped - unless the model was changed to something else+ // in the same tick (e.g. reset in a @change handler)+ if (!el._assigning || toRaw(value) !== toRaw(el._assignedValue)) { setSelected(el, value) } },
packages/runtime-dom/__tests__/directives/vModel.spec.tsindex 590c0d7df..429163126 100644@@ -1317,6 +1317,290 @@ describe('vModel', () => { expect(bar.selected).toEqual(true) }) + function mountSelectModel(+ initialValue: any,+ update: (value: any) => any,+ multiple = false,+ optionValues: any[] = ['foo', 'bar'],+ ) {+ const component = defineComponent({+ data: () => ({ value: initialValue }),+ render() {+ return withVModel(+ h(+ 'select',+ {+ multiple,+ 'onUpdate:modelValue': (value: any) => {+ this.value = update(value)+ },+ },+ optionValues.map(value => h('option', { value })),+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ return { input, options: input.options, data: root._vnode.component.data }+ }++ function trackSelectedWrites(input: HTMLSelectElement) {+ const selected = Object.getOwnPropertyDescriptor(+ HTMLOptionElement.prototype,+ 'selected',+ )!+ let writes = 0+ for (const option of input.options) {+ Object.defineProperty(option, 'selected', {+ configurable: true,+ get: selected.get,+ set(value) {+ writes+++ selected.set!.call(this, value)+ },+ })+ }+ return () => writes+ }++ it('should sync a multiple select when the Set model is overridden', async () => {+ const { input, options, data } = mountSelectModel(+ new Set<string>(),+ () => new Set(['foo']),+ true,+ )+ const foo = options[0]+ const bar = options[1]++ bar.selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(Array.from(data.value)).toEqual(['foo'])+ expect(foo.selected).toBe(true)+ expect(bar.selected).toBe(false)+ })++ it('should clear a single select when a native change handler clears the model', async () => {+ const component = defineComponent({+ data() {+ return { value: null as string | null }+ },+ render() {+ return withVModel(+ h(+ 'select',+ {+ 'onUpdate:modelValue': setValue.bind(this),+ onChange: () => {+ this.value = null+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ const data = root._vnode.component.data++ input.options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toBe(null)+ expect(input.selectedIndex).toBe(-1)+ })++ it('should preserve the selected option when duplicate values exist', async () => {+ const { input, options, data } = mountSelectModel(+ null,+ value => value,+ false,+ ['foo', 'foo'],+ )++ options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toBe('foo')+ expect(input.selectedIndex).toBe(1)+ })++ it('should resync when a multiple select becomes single during the pending update', async () => {+ const component = defineComponent({+ data() {+ return { value: [] as string[], multiple: true }+ },+ render() {+ return withVModel(+ h(+ 'select',+ {+ multiple: this.multiple,+ 'onUpdate:modelValue': (value: string[]) => {+ this.value = value+ this.multiple = false+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ const data = root._vnode.component.data++ input.options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toEqual(['bar'])+ expect(input.multiple).toBe(false)+ expect(input.selectedIndex).toBe(-1)+ })++ it('should snapshot an emitted Array before the change handler mutates it', async () => {+ const { input, options, data } = mountSelectModel(+ ['foo'],+ (value: string[]) => {+ value.pop()+ return value+ },+ true,+ )+ const foo = options[0]+ const bar = options[1]++ foo.selected = true+ bar.selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toEqual(['foo'])+ expect(foo.selected).toBe(true)+ expect(bar.selected).toBe(false)+ })++ it('should resync after the emitted Set is mutated in the change handler', async () => {+ const { input, options, data } = mountSelectModel(+ new Set(['foo']),+ (value: Set<string>) => {+ value.delete('bar')+ return value+ },+ true,+ )+ const foo = options[0]+ const bar = options[1]++ foo.selected = true+ bar.selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(Array.from(data.value)).toEqual(['foo'])+ expect(foo.selected).toBe(true)+ expect(bar.selected).toBe(false)+ })++ it('should not rewrite options after assigning a Set of objects', async () => {+ const fooValue = { id: 'foo' }+ const barValue = { id: 'bar' }+ const { input, options } = mountSelectModel(+ new Set([fooValue]),+ value => value,+ true,+ [fooValue, barValue],+ )++ options[0].selected = false+ options[1].selected = true+ const getWrites = trackSelectedWrites(input)+ triggerEvent('change', input)+ await nextTick()++ expect(getWrites()).toBe(0)+ })++ it('should not rewrite options after assigning an Array of objects', async () => {+ const fooValue = { id: 'foo' }+ const barValue = { id: 'bar' }+ const { input, options } = mountSelectModel([], value => value, true, [+ fooValue,+ barValue,+ ])++ options[1].selected = true+ const getWrites = trackSelectedWrites(input)+ triggerEvent('change', input)+ await nextTick()++ expect(getWrites()).toBe(0)+ })++ it('should not rewrite options for a primitive Array model', async () => {+ const optionValues = Array.from({ length: 10 }, (_, i) => i)+ const { input, options, data } = mountSelectModel(+ [],+ value => value,+ true,+ optionValues,+ )++ for (let i = 0; i < 5; i++) options[i].selected = true+ const getWrites = trackSelectedWrites(input)+ triggerEvent('change', input)+ await nextTick()++ expect(data.value).toHaveLength(5)+ expect(getWrites()).toBe(0)+ })++ it('should clear the pending assignment when the assigner throws', async () => {+ const error = new Error('assign failed')+ const component = defineComponent({+ data: () => ({ value: [] }),+ render() {+ return withVModel(+ h(+ 'select',+ {+ multiple: true,+ 'onUpdate:modelValue': () => {+ throw error+ },+ },+ [h('option', { value: 'foo' }), h('option', { value: 'bar' })],+ ),+ this.value,+ )+ },+ })+ render(h(component), root)+ const input = root.querySelector('select') as HTMLSelectElement+ const onError = vi.fn((event: ErrorEvent) => event.preventDefault())+ window.addEventListener('error', onError)++ try {+ input.options[1].selected = true+ triggerEvent('change', input)+ await nextTick()++ expect(onError).toHaveBeenCalled()+ expect((input as any)._pendingValue).toBeUndefined()+ } finally {+ window.removeEventListener('error', onError)+ }+ })+ it('multiple select uses current Array/Set model type', async () => { const component = defineComponent({ data() {packages/runtime-dom/src/directives/vModel.tsindex eeb248f28..041f17c5a 100644@@ -44,7 +44,7 @@ type ModelDirective<T, Modifiers extends string = string> = ObjectDirective< T & { [assignKey]: AssignerFn [initialValueKey]?: string- _assigning?: boolean+ _pendingValue?: [multiple: boolean, value: any] }, any, Modifiers@@ -240,17 +240,31 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { .map((o: HTMLOptionElement) => number ? looseToNumber(getValue(o)) : getValue(o), )- el[assignKey](- el.multiple- ? isSet((el as any)._modelValue)- ? new Set(selectedVal)+ const multiple = el.multiple+ const assignedValue = multiple+ ? isSet((el as any)._modelValue)+ ? new Set(selectedVal)+ : selectedVal+ : selectedVal[0]+ // Array models receive selectedVal directly, so snapshot it before user+ // code can mutate it. Set models already receive a fresh Set.+ const pending = (el._pendingValue = [+ multiple,+ multiple+ ? isArray(assignedValue)+ ? selectedVal.slice() : selectedVal- : selectedVal[0],- )- el._assigning = true- nextTick(() => {- el._assigning = false- })+ : assignedValue,+ ])+ try {+ el[assignKey](assignedValue)+ } finally {+ nextTick(() => {+ if (el._pendingValue === pending) {+ el._pendingValue = undefined+ }+ })+ } }) el[assignKey] = getModelAssigner(vnode) },@@ -264,12 +278,35 @@ export const vModelSelect: ModelDirective<HTMLSelectElement, 'number'> = { el[assignKey] = getModelAssigner(vnode) }, updated(el, { value }) {- if (!el._assigning) {+ const pending = el._pendingValue+ el._pendingValue = undefined+ if (+ !pending ||+ pending[0] !== el.multiple ||+ !isSameSelectValue(value, pending[1], pending[0])+ ) { setSelected(el, value) } }, } +function isSameSelectValue(+ value: any,+ assignedValue: any,+ multiple: boolean,+): boolean {+ if (!multiple) return looseEqual(value, assignedValue)+ if (isArray(value)) return looseEqual(value, assignedValue)+ if (isSet(value)) {+ if (value.size !== assignedValue.length) return false+ for (const item of assignedValue) {+ if (!value.has(item)) return false+ }+ return true+ }+ return false+}+ function setSelected(el: HTMLSelectElement, value: any) { const isMultiple = el.multiple const isArrayValue = isArray(value)