mvc-kit 2.12.0 → 2.12.2

package/src/Model.test.ts

@@ -0,0 +1,642 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Model } from './Model';
+import { Collection } from './Collection';
+import { EventBus } from './EventBus';
+import { singleton, teardownAll } from './singleton';
+import type { ValidationErrors } from './types';
+
+interface UserState {
+  name: string;
+  email: string;
+  age: number;
+}
+
+class UserModel extends Model<UserState> {
+  setName(name: string): void {
+    this.set({ name });
+  }
+
+  setEmail(email: string): void {
+    this.set({ email });
+  }
+
+  setAge(age: number): void {
+    this.set({ age });
+  }
+
+  update(partial: Partial<UserState>): void {
+    this.set(partial);
+  }
+}
+
+class ValidatedUserModel extends Model<UserState> {
+  protected validate(state: UserState): ValidationErrors<UserState> {
+    const errors: ValidationErrors<UserState> = {};
+
+    if (!state.name || state.name.trim() === '') {
+      errors.name = 'Name is required';
+    }
+
+    if (!state.email || !state.email.includes('@')) {
+      errors.email = 'Valid email is required';
+    }
+
+    if (state.age < 0 || state.age > 150) {
+      errors.age = 'Age must be between 0 and 150';
+    }
+
+    return errors;
+  }
+
+  setName(name: string): void {
+    this.set({ name });
+  }
+
+  setEmail(email: string): void {
+    this.set({ email });
+  }
+
+  setAge(age: number): void {
+    this.set({ age });
+  }
+}
+
+describe('Model', () => {
+  describe('state initialization', () => {
+    it('initializes with provided state', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.state).toEqual({ name: 'John', email: 'john@example.com', age: 30 });
+    });
+
+    it('state is frozen', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(Object.isFrozen(model.state)).toBe(true);
+    });
+
+    it('committed equals initial state', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.committed).toEqual(model.state);
+    });
+
+    it('starts not dirty', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.dirty).toBe(false);
+    });
+
+    it('starts not disposed', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.disposed).toBe(false);
+    });
+  });
+
+  describe('state updates', () => {
+    it('updates state immutably', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const prevState = model.state;
+      model.setName('Jane');
+      expect(model.state.name).toBe('Jane');
+      expect(model.state).not.toBe(prevState);
+    });
+
+    it('new state is frozen', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setName('Jane');
+      expect(Object.isFrozen(model.state)).toBe(true);
+    });
+
+    it('skips update when values unchanged', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const listener = vi.fn();
+      model.subscribe(listener);
+
+      model.setName('John'); // Same value
+      expect(listener).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('dirty tracking', () => {
+    it('becomes dirty after state change', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.dirty).toBe(false);
+      model.setName('Jane');
+      expect(model.dirty).toBe(true);
+    });
+
+    it('committed state does not change on set', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const committed = model.committed;
+      model.setName('Jane');
+      expect(model.committed).toBe(committed);
+      expect(model.committed.name).toBe('John');
+    });
+  });
+
+  describe('commit', () => {
+    it('marks current state as committed', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setName('Jane');
+      expect(model.dirty).toBe(true);
+
+      model.commit();
+      expect(model.dirty).toBe(false);
+      expect(model.committed.name).toBe('Jane');
+    });
+
+    it('throws on disposed model', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.dispose();
+      expect(() => model.commit()).toThrow('Cannot commit on disposed Model');
+    });
+  });
+
+  describe('rollback', () => {
+    it('reverts state to committed', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setName('Jane');
+      model.setAge(25);
+      expect(model.state.name).toBe('Jane');
+      expect(model.state.age).toBe(25);
+
+      model.rollback();
+      expect(model.state.name).toBe('John');
+      expect(model.state.age).toBe(30);
+      expect(model.dirty).toBe(false);
+    });
+
+    it('notifies listeners on rollback', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setName('Jane');
+
+      const listener = vi.fn();
+      model.subscribe(listener);
+      model.rollback();
+
+      expect(listener).toHaveBeenCalledWith(
+        { name: 'John', email: 'john@example.com', age: 30 },
+        { name: 'Jane', email: 'john@example.com', age: 30 }
+      );
+    });
+
+    it('does not notify if already at committed state', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const listener = vi.fn();
+      model.subscribe(listener);
+
+      model.rollback();
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it('throws on disposed model', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.dispose();
+      expect(() => model.rollback()).toThrow('Cannot rollback on disposed Model');
+    });
+  });
+
+  describe('validation', () => {
+    it('valid is true by default', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.valid).toBe(true);
+      expect(model.errors).toEqual({});
+    });
+
+    it('validates state', () => {
+      const model = new ValidatedUserModel({ name: '', email: 'invalid', age: 200 });
+      expect(model.valid).toBe(false);
+      expect(model.errors).toEqual({
+        name: 'Name is required',
+        email: 'Valid email is required',
+        age: 'Age must be between 0 and 150',
+      });
+    });
+
+    it('valid when all fields pass', () => {
+      const model = new ValidatedUserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.valid).toBe(true);
+      expect(model.errors).toEqual({});
+    });
+
+    it('updates validation on state change', () => {
+      const model = new ValidatedUserModel({ name: '', email: 'john@example.com', age: 30 });
+      expect(model.valid).toBe(false);
+      expect(model.errors.name).toBe('Name is required');
+
+      model.setName('John');
+      expect(model.valid).toBe(true);
+      expect(model.errors).toEqual({});
+    });
+  });
+
+  describe('subscriptions', () => {
+    it('notifies subscriber with next and prev state', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const listener = vi.fn();
+      model.subscribe(listener);
+
+      model.setName('Jane');
+
+      expect(listener).toHaveBeenCalledTimes(1);
+      expect(listener).toHaveBeenCalledWith(
+        { name: 'Jane', email: 'john@example.com', age: 30 },
+        { name: 'John', email: 'john@example.com', age: 30 }
+      );
+    });
+
+    it('unsubscribe function works', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const listener = vi.fn();
+      const unsubscribe = model.subscribe(listener);
+
+      model.setName('Jane');
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      unsubscribe();
+      model.setName('Bob');
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('dispose', () => {
+    it('sets disposed to true', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.dispose();
+      expect(model.disposed).toBe(true);
+    });
+
+    it('returns no-op on subscribe after dispose', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.dispose();
+      const unsub = model.subscribe(() => {});
+      expect(typeof unsub).toBe('function');
+      expect(() => unsub()).not.toThrow();
+    });
+
+    it('throws on set after dispose', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.dispose();
+      expect(() => model.setName('Jane')).toThrow('Cannot set state on disposed Model');
+    });
+  });
+
+  describe('init', () => {
+    it('starts not initialized', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.initialized).toBe(false);
+    });
+
+    it('sets initialized to true after init()', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.init();
+      expect(model.initialized).toBe(true);
+    });
+
+    it('calls onInit hook', () => {
+      let called = false;
+      class InitModel extends Model<UserState> {
+        protected onInit() {
+          called = true;
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+      const model = new InitModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.init();
+      expect(called).toBe(true);
+    });
+
+    it('is idempotent — onInit called only once', () => {
+      let callCount = 0;
+      class CountingModel extends Model<UserState> {
+        protected onInit() {
+          callCount++;
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+      const model = new CountingModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.init();
+      model.init();
+      model.init();
+      expect(callCount).toBe(1);
+    });
+
+    it('supports async onInit', async () => {
+      let resolved = false;
+      class AsyncModel extends Model<UserState> {
+        protected async onInit() {
+          await Promise.resolve();
+          resolved = true;
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+      const model = new AsyncModel({ name: 'John', email: 'john@example.com', age: 30 });
+      await model.init();
+      expect(resolved).toBe(true);
+    });
+
+    it('is a no-op after dispose', () => {
+      let called = false;
+      class InitModel extends Model<UserState> {
+        protected onInit() {
+          called = true;
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+      const model = new InitModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.dispose();
+      model.init();
+      expect(called).toBe(false);
+      expect(model.initialized).toBe(false);
+    });
+
+    it('can set state in onInit', () => {
+      class InitSetModel extends Model<UserState> {
+        protected onInit() {
+          this.set({ name: 'Initialized' });
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+      const model = new InitSetModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.init();
+      expect(model.state.name).toBe('Initialized');
+    });
+  });
+
+  describe('singleton integration', () => {
+    beforeEach(() => {
+      teardownAll();
+    });
+
+    it('can be used with singleton registry', () => {
+      const m1 = singleton(UserModel, { name: 'John', email: 'john@example.com', age: 30 });
+      const m2 = singleton(UserModel, { name: 'Jane', email: 'jane@example.com', age: 25 });
+      expect(m1).toBe(m2);
+      expect(m2.state.name).toBe('John');
+    });
+  });
+
+  describe('signal and addCleanup', () => {
+    it('signal returns an AbortSignal', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.disposeSignal).toBeInstanceOf(AbortSignal);
+    });
+
+    it('returns the same signal on multiple accesses', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const s1 = model.disposeSignal;
+      const s2 = model.disposeSignal;
+      expect(s1).toBe(s2);
+    });
+
+    it('signal is not aborted before dispose', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      expect(model.disposeSignal.aborted).toBe(false);
+    });
+
+    it('signal is aborted after dispose', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const signal = model.disposeSignal;
+      model.dispose();
+      expect(signal.aborted).toBe(true);
+    });
+
+    it('signal is aborted before onDispose runs', () => {
+      let wasAbortedDuringDispose = false;
+      class CheckModel extends Model<UserState> {
+        protected onDispose(): void {
+          wasAbortedDuringDispose = this.disposeSignal.aborted;
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+      const model = new CheckModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.disposeSignal; // force lazy creation
+      model.dispose();
+      expect(wasAbortedDuringDispose).toBe(true);
+    });
+
+    it('addCleanup fires on dispose', () => {
+      let cleaned = false;
+      class CleanupModel extends Model<UserState> {
+        setup() {
+          this.addCleanup(() => { cleaned = true; });
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+      const model = new CleanupModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setup();
+      expect(cleaned).toBe(false);
+      model.dispose();
+      expect(cleaned).toBe(true);
+    });
+
+    it('dispose works without accessing signal (lazy, zero cost)', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.dispose();
+      expect(model.disposed).toBe(true);
+    });
+  });
+
+  describe('subscribeTo', () => {
+    interface Item { id: string; value: number }
+
+    it('listener is called when source changes', () => {
+      const collection = new Collection<Item>();
+
+      class SubModel extends Model<UserState> {
+        values: number[] = [];
+        setup(col: Collection<Item>) {
+          this.subscribeTo(col, (items) => {
+            this.values = items.map(i => i.value);
+          });
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+
+      const model = new SubModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setup(collection);
+
+      collection.add({ id: '1', value: 42 });
+      expect(model.values).toEqual([42]);
+    });
+
+    it('auto-unsubscribes on dispose', () => {
+      const collection = new Collection<Item>();
+      const listener = vi.fn();
+
+      class SubModel extends Model<UserState> {
+        setup(col: Collection<Item>) {
+          this.subscribeTo(col, listener);
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+
+      const model = new SubModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setup(collection);
+
+      collection.add({ id: '1', value: 1 });
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      model.dispose();
+
+      collection.add({ id: '2', value: 2 });
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns unsubscribe function for manual cleanup', () => {
+      const collection = new Collection<Item>();
+      const listener = vi.fn();
+
+      class SubModel extends Model<UserState> {
+        setup(col: Collection<Item>): () => void {
+          return this.subscribeTo(col, listener);
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+
+      const model = new SubModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const unsub = model.setup(collection);
+
+      collection.add({ id: '1', value: 1 });
+      expect(listener).toHaveBeenCalledTimes(1);
+
+      unsub();
+
+      collection.add({ id: '2', value: 2 });
+      expect(listener).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('listenTo', () => {
+    interface TestEvents {
+      update: { field: string };
+    }
+
+    it('handler is called when event is emitted', () => {
+      const bus = new EventBus<TestEvents>();
+      const updates: TestEvents['update'][] = [];
+
+      class ListenModel extends Model<UserState> {
+        setup(b: EventBus<TestEvents>) {
+          this.listenTo(b, 'update', (u) => updates.push(u));
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+
+      const model = new ListenModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setup(bus);
+
+      bus.emit('update', { field: 'name' });
+      expect(updates).toEqual([{ field: 'name' }]);
+    });
+
+    it('auto-unsubscribes on dispose', () => {
+      const bus = new EventBus<TestEvents>();
+      const handler = vi.fn();
+
+      class ListenModel extends Model<UserState> {
+        setup(b: EventBus<TestEvents>) {
+          this.listenTo(b, 'update', handler);
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+
+      const model = new ListenModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setup(bus);
+
+      bus.emit('update', { field: 'name' });
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      model.dispose();
+
+      bus.emit('update', { field: 'email' });
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+
+    it('returns unsubscribe function for manual cleanup', () => {
+      const bus = new EventBus<TestEvents>();
+      const handler = vi.fn();
+
+      class ListenModel extends Model<UserState> {
+        setup(b: EventBus<TestEvents>): () => void {
+          return this.listenTo(b, 'update', handler);
+        }
+        setName(name: string) { this.set({ name }); }
+      }
+
+      const model = new ListenModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const unsub = model.setup(bus);
+
+      bus.emit('update', { field: 'name' });
+      expect(handler).toHaveBeenCalledTimes(1);
+
+      unsub();
+
+      bus.emit('update', { field: 'email' });
+      expect(handler).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('method binding', () => {
+    it('destructured base class methods work point-free', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      model.setName('Jane');
+      const { commit, rollback } = model;
+      commit();
+      expect(model.committed.name).toBe('Jane');
+      model.setName('Bob');
+      rollback();
+      expect(model.state.name).toBe('Jane');
+    });
+
+    it('subclass methods are bound', () => {
+      const model = new UserModel({ name: 'John', email: 'john@example.com', age: 30 });
+      const { setName, setAge } = model;
+      setName('Jane');
+      expect(model.state.name).toBe('Jane');
+      setAge(25);
+      expect(model.state.age).toBe(25);
+    });
+  });
+
+  describe('draft mode in set()', () => {
+    class DraftModel extends Model<UserState> {
+      draftName(name: string) {
+        this.set((d) => { d.name = name; });
+      }
+
+      updaterName(name: string) {
+        this.set(() => ({ name }));
+      }
+    }
+
+    it('draft mutation updates state', () => {
+      const model = new DraftModel({ name: 'John', email: 'j@e.com', age: 30 });
+      model.draftName('Jane');
+      expect(model.state.name).toBe('Jane');
+    });
+
+    it('draft no-op does not notify listeners', () => {
+      const model = new DraftModel({ name: 'John', email: 'j@e.com', age: 30 });
+      const listener = vi.fn();
+      model.subscribe(listener);
+
+      model.draftName('John'); // same value
+      expect(listener).not.toHaveBeenCalled();
+    });
+
+    it('existing updater pattern still works', () => {
+      const model = new DraftModel({ name: 'John', email: 'j@e.com', age: 30 });
+      model.updaterName('Jane');
+      expect(model.state.name).toBe('Jane');
+    });
+
+    it('draft updates dirty tracking correctly', () => {
+      const model = new DraftModel({ name: 'John', email: 'j@e.com', age: 30 });
+      expect(model.dirty).toBe(false);
+
+      model.draftName('Jane');
+      expect(model.dirty).toBe(true);
+
+      model.commit();
+      expect(model.dirty).toBe(false);
+    });
+  });
+});