feat: add tests for abstract view model store

Author: js2me

src/view-model/abstract-view-model.store.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { AbstractViewModelStore } from './abstract-view-model.store';
+import { TestViewModelImpl } from './abstract-view-model.test';
+import { AbstractViewModelParams } from './abstract-view-model.types';
+import {
+  ViewModelCreateConfig,
+  ViewModelGenerateIdConfig,
+} from './view-model.store.types';
+
+export class TestViewModelStoreImpl extends AbstractViewModelStore<TestViewModelImpl> {
+  spies = {
+    generateViewModelId: vi.fn(),
+  };
+
+  createViewModel<VM extends TestViewModelImpl>(
+    config: ViewModelCreateConfig<VM>,
+  ): VM {
+    const VM = config.VM;
+
+    const params: AbstractViewModelParams<VM['payload']> = {
+      id: config.id,
+      payload: config.payload,
+      parentViewModelId: config.parentViewModelId,
+    };
+
+    return new VM(params);
+  }
+
+  generateViewModelId<VM extends TestViewModelImpl>(
+    config: ViewModelGenerateIdConfig<VM>,
+  ): string {
+    const result = super.generateViewModelId(config);
+    this.spies.generateViewModelId(result, config);
+    return result;
+  }
+}
+
+const createTestViewModelStore = () => {
+  return new TestViewModelStoreImpl();
+};
+
+describe('AbstractViewModelStore', () => {
+  it('create instance', () => {
+    const vmStore = createTestViewModelStore();
+    expect(vmStore).toBeDefined();
+  });
+
+  it('is able to attach view model', async () => {
+    const vmStore = createTestViewModelStore();
+    const vm = new TestViewModelImpl({ id: '1', payload: '1' });
+    await vmStore.attach(vm);
+    expect(vmStore.get('1')).toBe(vm);
+    expect(vmStore.instanceAttachedCount.get('1')).toBe(1);
+  });
+
+  it('is able to detach view model', async () => {
+    const vmStore = createTestViewModelStore();
+    const vm = new TestViewModelImpl({ id: '1', payload: '1' });
+    await vmStore.attach(vm);
+    await vmStore.detach('1');
+    expect(vmStore.get('1')).toBe(null);
+    expect(vmStore.instanceAttachedCount.get('1')).toBe(undefined);
+  });
+});

src/view-model/abstract-view-model.store.ts

@@ -19,8 +19,11 @@ import {
 
 declare const process: { env: { NODE_ENV?: string } };
 
-export abstract class AbstractViewModelStore implements ViewModelStore {
-  viewModels = observable.map<string, ViewModel>();
+export abstract class AbstractViewModelStore<
+  VMBase extends ViewModel<any> = ViewModel<any>,
+> implements ViewModelStore<VMBase>
+{
+  viewModels = observable.map<string, VMBase>();
   viewModelsByClasses = observable.map<string, string[]>();
 
   instanceAttachedCount = new Map<string, number>();
@@ -52,11 +55,11 @@ export abstract class AbstractViewModelStore implements ViewModelStore {
     );
   }
 
-  abstract createViewModel<VM extends ViewModel<any>>(
+  abstract createViewModel<VM extends VMBase>(
     config: ViewModelCreateConfig<VM>,
   ): VM;
 
-  generateViewModelId<VM extends ViewModel<any>>(
+  generateViewModelId<VM extends VMBase>(
     config: ViewModelGenerateIdConfig<VM>,
   ): string {
     if (config.id) {
@@ -79,9 +82,7 @@ export abstract class AbstractViewModelStore implements ViewModelStore {
     }
   }
 
-  getId<T extends ViewModel>(
-    idOrClass: Maybe<string | Class<T>>,
-  ): string | null {
+  getId<T extends VMBase>(idOrClass: Maybe<string | Class<T>>): string | null {
     if (!idOrClass) return null;
 
     const id =
@@ -94,23 +95,23 @@ export abstract class AbstractViewModelStore implements ViewModelStore {
     return id;
   }
 
-  has<T extends ViewModel>(idOrClass: Maybe<string | Class<T>>): boolean {
+  has<T extends VMBase>(idOrClass: Maybe<string | Class<T>>): boolean {
     const id = this.getId(idOrClass);
 
     if (!id) return false;
 
     return this.viewModels.has(id);
   }
 
-  get<T extends ViewModel>(idOrClass: Maybe<string | Class<T>>): T | null {
+  get<T extends VMBase>(idOrClass: Maybe<string | Class<T>>): T | null {
     const id = this.getId(idOrClass);
 
     if (!id) return null;
 
     return (this.viewModels.get(id) as Maybe<T>) ?? null;
   }
 
-  async mount(model: ViewModel) {
+  async mount(model: VMBase) {
     this.mountingViews.add(model.id);
 
     await model.mount();
@@ -120,7 +121,7 @@ export abstract class AbstractViewModelStore implements ViewModelStore {
     });
   }
 
-  async unmount(model: ViewModel) {
+  async unmount(model: VMBase) {
     this.unmountingViews.add(model.id);
 
     await model.unmount();
@@ -130,7 +131,7 @@ export abstract class AbstractViewModelStore implements ViewModelStore {
     });
   }
 
-  async attach(model: ViewModel) {
+  async attach(model: VMBase) {
     const attachedCount = this.instanceAttachedCount.get(model.id) ?? 0;
 
     this.instanceAttachedCount.set(model.id, attachedCount + 1);

src/view-model/abstract-view-model.test.ts

@@ -5,103 +5,102 @@ import { Maybe } from '../utils/types';
 import { AbstractViewModel } from './abstract-view-model';
 import { ViewModel } from './view-model';
 
-const createTestViewModel = ({
+export class TestViewModelImpl extends AbstractViewModel<any, any> {
+  spies = {
+    mount: vi.fn(),
+    unmount: vi.fn(),
+    payloadChanged: vi.fn(),
+    didMount: vi.fn(),
+    didUnmount: vi.fn(),
+  };
+
+  protected getParentViewModel(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    parentViewModelId: Maybe<string>,
+  ): ViewModel<any, ViewModel<any, any>> | null {
+    throw new Error('Method not implemented.');
+  }
+
+  didMount(): void {
+    this.spies.didMount();
+  }
+
+  mount(): void {
+    super.mount();
+    this.spies.mount();
+  }
+
+  unmount(): void {
+    super.unmount();
+    this.spies.unmount();
+  }
+
+  payloadChanged(payload: any): void {
+    this.spies.payloadChanged(payload);
+  }
+
+  didUnmount(): void {
+    this.spies.didUnmount();
+  }
+}
+export const createTestViewModel = ({
   id = '1',
   payload = {},
 }: {
   id?: string;
   payload?: any;
 } = {}) => {
-  class ViewModelImpl extends AbstractViewModel<any> {
-    spies = {
-      mount: vi.fn(),
-      unmount: vi.fn(),
-      payloadChanged: vi.fn(),
-      didMount: vi.fn(),
-      didUnmount: vi.fn(),
-    };
-
-    protected getParentViewModel(
-      // eslint-disable-next-line @typescript-eslint/no-unused-vars
-      parentViewModelId: Maybe<string>,
-    ): ViewModel<any, ViewModel<any, any>> | null {
-      throw new Error('Method not implemented.');
-    }
-
-    didMount(): void {
-      this.spies.didMount();
-    }
-
-    mount(): void {
-      super.mount();
-      this.spies.mount();
-    }
-
-    unmount(): void {
-      super.unmount();
-      this.spies.unmount();
-    }
-
-    payloadChanged(payload: any): void {
-      this.spies.payloadChanged(payload);
-    }
-
-    didUnmount(): void {
-      this.spies.didUnmount();
-    }
-  }
-
-  const vm = new ViewModelImpl({ id, payload });
+  const vm = new TestViewModelImpl({ id, payload });
 
   return vm;
 };
 
 describe('AbstractViewModel', () => {
   it('create instance', () => {
-    const vm = createTestViewModel();
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
     expect(vm).toBeDefined();
   });
 
   it('has id', () => {
-    const vm = createTestViewModel({ id: '1' });
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
     expect(vm.id).toBe('1');
   });
 
   it('has payload', () => {
-    const vm = createTestViewModel({ payload: { test: 1 } });
+    const vm = new TestViewModelImpl({ id: '1', payload: { test: 1 } });
     expect(vm.payload).toEqual({ test: 1 });
   });
 
   it('has isMounted', () => {
-    const vm = createTestViewModel();
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
     expect(vm.isMounted).toBe(false);
   });
 
   it('has mount method', () => {
-    const vm = createTestViewModel();
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
     expect(vm.mount).toBeDefined();
   });
 
   it('has unmount method', () => {
-    const vm = createTestViewModel();
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
     expect(vm.unmount).toBeDefined();
   });
 
   it('has dispose', () => {
-    const vm = createTestViewModel();
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
     expect(vm.dispose).toBeDefined();
   });
 
   it('mount should be called once', () => {
-    const vm = createTestViewModel();
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
 
     vm.mount();
 
     expect(vm.spies.mount).toHaveBeenCalledOnce();
   });
 
   it('didMount should be called after mount', () => {
-    const vm = createTestViewModel();
+    const vm = new TestViewModelImpl({ id: '1', payload: {} });
 
     vm.mount();
 

src/view-model/abstract-view-model.ts

@@ -25,8 +25,6 @@ export abstract class AbstractViewModel<
     this.id = params.id;
     this.payload = params.payload;
 
-    console.info('fff');
-
     makeObservable(this, {
       isMounted: observable.ref,
       payload: observable.ref,

src/view-model/view-model.store.ts

@@ -12,14 +12,15 @@ import {
  * Interface representing a store for managing view models.
  * It extends the Disposable interface, allowing for cleanup of resources.
  */
-export interface ViewModelStore extends Disposable {
+export interface ViewModelStore<VMBase extends ViewModel<any> = ViewModel<any>>
+  extends Disposable {
   /**
    * Retrieves the ID of a view model based on a given ID or class type.
    * @param idOrClass - The ID or class type of the view model.
    * @returns The ID of the view model, or null if not found.
    */
-  getId<T extends ViewModel<any>>(
-    idOrClass: Maybe<ViewModel['id'] | Class<T>>,
+  getId<T extends VMBase>(
+    idOrClass: Maybe<VMBase['id'] | Class<T>>,
   ): string | null;
 
   /**
@@ -32,55 +33,49 @@ export interface ViewModelStore extends Disposable {
    * @param idOrClass - The ID or class type of the view model.
    * @returns True if the instance exists, false otherwise.
    */
-  has<T extends ViewModel<any>>(
-    idOrClass: Maybe<ViewModel['id'] | Class<T>>,
-  ): boolean;
+  has<T extends VMBase>(idOrClass: Maybe<VMBase['id'] | Class<T>>): boolean;
 
   /**
    * Retrieves a view model instance from the store.
    * @param idOrClass - The ID or class type of the view model.
    * @returns The view model instance, or null if not found.
    */
-  get<T extends ViewModel<any>>(
-    idOrClass: Maybe<ViewModel['id'] | Class<T>>,
-  ): T | null;
+  get<T extends VMBase>(idOrClass: Maybe<VMBase['id'] | Class<T>>): T | null;
 
   /**
    * Attaches a view model to the store.
    * @param model - The view model to attach.
    * @returns A promise that resolves when the operation is complete.
    */
-  attach(model: ViewModel): Promise<void>;
+  attach(model: VMBase): Promise<void>;
 
   /**
    * Detaches a view model from the store using its ID.
    * @param id - The ID of the view model to detach.
    * @returns A promise that resolves when the operation is complete.
    */
-  detach(id: ViewModel['id']): Promise<void>;
+  detach(id: VMBase['id']): Promise<void>;
 
   /**
    * Determines if a view model is able to render based on its ID.
    * @param id - The ID of the view model.
    * @returns True if the view model can render, false otherwise.
    */
-  isAbleToRenderView(id: Maybe<ViewModel['id']>): boolean;
+  isAbleToRenderView(id: Maybe<VMBase['id']>): boolean;
 
   /**
    * Creates a new view model instance based on the provided configuration.
    * @param config - The configuration for creating the view model.
    * @returns The newly created view model instance.
    */
-  createViewModel<VM extends ViewModel<any>>(
-    config: ViewModelCreateConfig<VM>,
-  ): VM;
+  createViewModel<VM extends VMBase>(config: ViewModelCreateConfig<VM>): VM;
 
   /**
    * Generates a unique ID for a view model based on the provided configuration.
    * @param config - The configuration for generating the ID.
    * @returns The generated unique ID.
    */
-  generateViewModelId<VM extends ViewModel<any>>(
+  generateViewModelId<VM extends VMBase>(
     config: ViewModelGenerateIdConfig<VM>,
   ): string;
 }