Inconsistent event ordering during model validation failure

Direct Answers

1. Is the error event guaranteed to fire before any change events if validation fails? Yes. When validate returns an error object, Backbone aborts the attribute merge before entering the change-event loop. The error event fires, and no change, change:attribute, or change:* events are emitted.

2. Does the model remain entirely untouched if validate throws an exception versus returning an error object? Returning an error object leaves the model pristine—attributes are not merged. Throwing an exception is not guaranteed to trigger the error event; the exception may bubble out of set()/save() before Backbone’s internal error handler runs, leaving the model unchanged but without a predictable event signal.

Why This Happens

Backbone’s set() (used by save()) follows this sequence:

1. Compute new attributes.
2. Call validate(attrs, options).
3. If validate returns a truthy value, treat it as an error object, fire error, and return false without mutating this.attributes.
4. If validate throws, the exception escapes set() unless caught by a wrapper. Backbone 1.x does not wrap the call in a try/catch that converts thrown errors into the error event.
5. Only after validation passes does Backbone merge attributes and fire change events.

Therefore, no change events can fire when validation fails via return value. The race conditions in tests usually come from asynchronous save() wrappers (e.g., wait: true or custom success/error callbacks) rather than the synchronous validation path.

Verification Steps

const Model = Backbone.Model.extend({
  validate(attrs) {
    if (attrs.forbidden) return 'forbidden value';
  }
});

const m = new Model({a: 1});
m.on('error', (model, err) => console.log('error:', err));
m.on('change', () => console.log('change fired'));
m.on('change:a', () => console.log('change:a fired'));

console.log('before:', m.attributes);
const result = m.set({forbidden: true});
console.log('set returned:', result);
console.log('after:', m.attributes);

Expected output: error: forbidden value, set returned: false, model still {a: 1}, no change logs.

Exception Case Test

const ThrowModel = Backbone.Model.extend({
  validate() { throw new Error('boom'); }
});
const tm = new ThrowModel({x: 1});
tm.on('error', () => console.log('error event'));
try {
  tm.set({y: 2});
} catch (e) {
  console.log('caught:', e.message);
}
console.log('attributes:', tm.attributes);

Run this in your target browser/environment. If error event does not appear but caught: boom does, the exception bypassed Backbone’s event system.

One Diagnostic Detail

Are you using save({...}, {wait: true}) or a custom sync implementation? That changes whether the error event you observe comes from client-side validation or from the server response, and it affects the timing guarantees you can rely on in tests.