@smartsoft001-mobilems/claude-plugins 2.58.0

package/plugins/flow/skills/test-unit/SKILL.md

@@ -0,0 +1,456 @@
+---
+name: test-unit
+description: Write unit tests following project conventions. Generates Jest tests for Angular components, services, and NestJS services using AAA pattern.
+allowed-tools:
+  - Bash
+  - Read
+  - Write
+  - Edit
+  - Glob
+  - Grep
+---
+
+# Unit Test Skill
+
+Write unit tests following project conventions using Jest framework with AAA (Arrange-Act-Assert) pattern.
+
+## Testing Framework
+
+- **Framework**: Jest for all unit tests
+- **File naming**: `{name}.spec.ts` alongside source files
+- **Test runner**: Nx (`nx test {project}`)
+
+## Test File Location
+
+Place test files next to the source files they test:
+
+```
+feature/
+├── feature.service.ts
+├── feature.service.spec.ts
+├── feature.component.ts
+└── feature.component.spec.ts
+```
+
+## Naming Convention
+
+- **Describe blocks**: `@{package-name}: ClassName`
+- **Test format**: `it('should...')` with clear behavior description
+
+## Test Structure (AAA Pattern)
+
+Always use Arrange-Act-Assert pattern with blank line separation (no comments):
+
+```typescript
+it('should perform expected operation', () => {
+  const input = 'test';
+
+  const result = service.performOperation(input);
+
+  expect(result).toBe('expected output');
+});
+```
+
+## Angular Component Testing
+
+### Basic Component Test
+
+```typescript
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { FeatureComponent } from './feature.component';
+
+describe('@mms/shared-angular: FeatureComponent', () => {
+  let component: FeatureComponent;
+  let fixture: ComponentFixture<FeatureComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [FeatureComponent], // Standalone components
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(FeatureComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('should display expected content', () => {
+    component.title = 'Test Title';
+    fixture.detectChanges();
+
+    const compiled = fixture.nativeElement;
+    expect(compiled.querySelector('h1')?.textContent).toContain('Test Title');
+  });
+});
+```
+
+### Testing Signal-based Components
+
+```typescript
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { signal } from '@angular/core';
+
+import { SignalComponent } from './signal.component';
+
+describe('@mms/shared-angular: SignalComponent', () => {
+  let component: SignalComponent;
+  let fixture: ComponentFixture<SignalComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [SignalComponent],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(SignalComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should update when signal changes', () => {
+    component.count.set(5);
+    fixture.detectChanges();
+
+    expect(fixture.nativeElement.textContent).toContain('5');
+  });
+
+  it('should compute derived value', () => {
+    component.items.set([1, 2, 3]);
+
+    expect(component.total()).toBe(6);
+  });
+});
+```
+
+### Testing Components with input()/output()
+
+```typescript
+describe('@mms/shared-angular: InputOutputComponent', () => {
+  let component: InputOutputComponent;
+  let fixture: ComponentFixture<InputOutputComponent>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      imports: [InputOutputComponent],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(InputOutputComponent);
+    component = fixture.componentInstance;
+  });
+
+  it('should accept input value', () => {
+    fixture.componentRef.setInput('value', 'test');
+    fixture.detectChanges();
+
+    expect(component.value()).toBe('test');
+  });
+
+  it('should emit output event', () => {
+    const spy = jest.fn();
+    component.changed.subscribe(spy);
+
+    component.emitChange('new value');
+
+    expect(spy).toHaveBeenCalledWith('new value');
+  });
+});
+```
+
+### Testing with Services
+
+```typescript
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+
+import { FeatureComponent } from './feature.component';
+import { DataService } from './data.service';
+
+describe('@mms/shared-angular: FeatureComponent', () => {
+  let component: FeatureComponent;
+  let fixture: ComponentFixture<FeatureComponent>;
+  let mockDataService: jest.Mocked<DataService>;
+
+  beforeEach(async () => {
+    mockDataService = {
+      getData: jest.fn().mockReturnValue(of(['item1', 'item2'])),
+      saveData: jest.fn().mockReturnValue(of(true)),
+    } as unknown as jest.Mocked<DataService>;
+
+    await TestBed.configureTestingModule({
+      imports: [FeatureComponent],
+      providers: [{ provide: DataService, useValue: mockDataService }],
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(FeatureComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should load data on init', () => {
+    expect(mockDataService.getData).toHaveBeenCalled();
+    expect(component.items()).toEqual(['item1', 'item2']);
+  });
+});
+```
+
+## Angular Service Testing
+
+```typescript
+import { TestBed } from '@angular/core/testing';
+import {
+  HttpTestingController,
+  provideHttpClientTesting,
+} from '@angular/common/http/testing';
+import { provideHttpClient } from '@angular/common/http';
+
+import { DataService } from './data.service';
+
+describe('@mms/shared-angular: DataService', () => {
+  let service: DataService;
+  let httpMock: HttpTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [DataService, provideHttpClient(), provideHttpClientTesting()],
+    });
+
+    service = TestBed.inject(DataService);
+    httpMock = TestBed.inject(HttpTestingController);
+  });
+
+  afterEach(() => {
+    httpMock.verify();
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+
+  it('should fetch data', () => {
+    const mockData = [{ id: 1, name: 'Test' }];
+
+    service.getData().subscribe((data) => {
+      expect(data).toEqual(mockData);
+    });
+
+    const req = httpMock.expectOne('/api/data');
+    expect(req.request.method).toBe('GET');
+    req.flush(mockData);
+  });
+});
+```
+
+## NestJS Service Testing
+
+### Basic Service Test
+
+```typescript
+import { TestingModule, Test } from '@nestjs/testing';
+
+import { FeatureService } from './feature.service';
+
+describe('@mms/module-name: FeatureService', () => {
+  let service: FeatureService;
+  let module: TestingModule;
+
+  beforeEach(async () => {
+    module = await Test.createTestingModule({
+      providers: [FeatureService],
+    }).compile();
+
+    service = module.get<FeatureService>(FeatureService);
+  });
+
+  afterEach(async () => {
+    await module.close();
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  it('should perform expected operation', () => {
+    const input = 'test';
+
+    const result = service.performOperation(input);
+
+    expect(result).toBe('expected output');
+  });
+});
+```
+
+### Service with Repository
+
+```typescript
+import { TestingModule, Test } from '@nestjs/testing';
+import { getRepositoryToken } from '@nestjs/typeorm';
+
+import { UserService } from './user.service';
+import { User } from './user.entity';
+
+describe('@mms/module-name: UserService', () => {
+  let service: UserService;
+  let module: TestingModule;
+  let mockRepository: Record<string, jest.Mock>;
+
+  beforeEach(async () => {
+    mockRepository = {
+      findOne: jest.fn(),
+      find: jest.fn(),
+      save: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+    };
+
+    module = await Test.createTestingModule({
+      providers: [
+        UserService,
+        {
+          provide: getRepositoryToken(User),
+          useValue: mockRepository,
+        },
+      ],
+    }).compile();
+
+    service = module.get<UserService>(UserService);
+  });
+
+  afterEach(async () => {
+    await module.close();
+  });
+
+  it('should find user by id', async () => {
+    const mockUser = { id: '1', name: 'Test User' };
+    mockRepository.findOne.mockResolvedValue(mockUser);
+
+    const result = await service.findById('1');
+
+    expect(result).toEqual(mockUser);
+    expect(mockRepository.findOne).toHaveBeenCalledWith({ where: { id: '1' } });
+  });
+});
+```
+
+## Mocking Patterns
+
+### HTTP Client Mock
+
+```typescript
+const mockHttpClient = {
+  get: jest.fn(),
+  post: jest.fn(),
+  put: jest.fn(),
+  delete: jest.fn(),
+};
+```
+
+### Service Mock
+
+```typescript
+const mockService = {
+  getData: jest.fn().mockReturnValue(of(mockData)),
+  createItem: jest.fn().mockReturnValue(of(mockItem)),
+  updateItem: jest.fn().mockReturnValue(of(updatedMockItem)),
+};
+```
+
+### LocalStorage Mock
+
+```typescript
+let localStorageMock: any;
+
+beforeEach(() => {
+  localStorageMock = (() => {
+    let store: Record<string, string> = {};
+    return {
+      getItem: jest.fn((key: string) => store[key] || null),
+      setItem: jest.fn((key: string, value: string) => {
+        store[key] = value;
+      }),
+      removeItem: jest.fn((key: string) => {
+        delete store[key];
+      }),
+      clear: jest.fn(() => {
+        store = {};
+      }),
+    };
+  })();
+  Object.defineProperty(window, 'localStorage', { value: localStorageMock });
+});
+```
+
+## Test Data Factory Pattern
+
+```typescript
+export const createMockUser = (overrides: Partial<User> = {}): User => ({
+  id: 'test-id',
+  login: 'testuser',
+  name: 'Test',
+  surname: 'User',
+  email: 'test@example.com',
+  phoneNumber: '+1234567890',
+  del: false,
+  createdAt: new Date(),
+  updatedAt: new Date(),
+  ...overrides,
+});
+```
+
+## Test Commands
+
+```bash
+# Run tests for specific project
+nx test web
+nx test shared-angular
+
+# Run tests in watch mode
+nx test web --watch
+
+# Run tests with coverage
+nx test web --coverage
+
+# Run all tests
+nx run-many --target=test
+
+# Run specific test file
+nx test shared-angular --testFile=feature.service.spec.ts
+```
+
+## What to Test
+
+- Business logic in services
+- Component behavior and state changes
+- Public API contracts
+- Error handling scenarios
+- Input validation
+- Edge cases and boundary conditions
+
+## What NOT to Test
+
+- Third-party libraries
+- Framework internals (Angular/NestJS)
+- Simple getters/setters without logic
+- Auto-generated code
+- Private methods directly (test through public API)
+
+## Workflow
+
+1. **Read source file** to understand the code being tested
+2. **Create test file** with `.spec.ts` extension next to source
+3. **Write describe block** with package and class name
+4. **Add beforeEach** with TestBed/Test setup
+5. **Write tests** using AAA pattern
+6. **Run tests** with `nx test {project}`
+7. **Fix failures** and ensure all pass
+
+## Best Practices
+
+1. **One assertion per test** when practical
+2. **Descriptive test names** that explain behavior
+3. **Independent tests** - no shared state between tests
+4. **Mock external dependencies** - isolate unit under test
+5. **Test edge cases** - empty arrays, null values, boundaries
+6. **Keep tests fast** - avoid real HTTP calls or timers
+7. **Clean up** - use afterEach for cleanup when needed

package/src/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @smartsoft001-mobilems/claude-plugins
+ *
+ * This library contains Claude Code plugin configuration files (MD/JSON).
+ */
+export declare const CLAUDE_PLUGINS_VERSION = "1.0.0";

package/src/index.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * @smartsoft001-mobilems/claude-plugins
+ *
+ * This library contains Claude Code plugin configuration files (MD/JSON).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAUDE_PLUGINS_VERSION = void 0;
+exports.CLAUDE_PLUGINS_VERSION = '1.0.0';
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../packages/shared/claude-plugins/src/index.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;AAEU,QAAA,sBAAsB,GAAG,OAAO,CAAC"}