aigroup-workflow 2.1.1 → 2.2.0

package/skills/java-architect/references/testing-patterns.md

@@ -1,500 +0,0 @@
-# Testing Patterns
-
-## Unit Testing with JUnit 5
-
-```java
-package com.example.application.service;
-
-import com.example.application.dto.UserRequest;
-import com.example.application.dto.UserResponse;
-import com.example.application.mapper.UserMapper;
-import com.example.domain.model.User;
-import com.example.domain.repository.UserRepository;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.DisplayName;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.ValueSource;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.jupiter.MockitoExtension;
-
-import java.util.Optional;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.ArgumentMatchers.*;
-import static org.mockito.Mockito.*;
-
-@ExtendWith(MockitoExtension.class)
-@DisplayName("User Service Tests")
-class UserServiceTest {
-
-    @Mock
-    private UserRepository userRepository;
-
-    @Mock
-    private UserMapper userMapper;
-
-    @InjectMocks
-    private UserService userService;
-
-    private User testUser;
-    private UserRequest userRequest;
-    private UserResponse userResponse;
-
-    @BeforeEach
-    void setUp() {
-        testUser = User.builder()
-            .id(1L)
-            .email("test@example.com")
-            .username("testuser")
-            .active(true)
-            .build();
-
-        userRequest = new UserRequest("test@example.com", "testuser");
-        userResponse = new UserResponse(1L, "test@example.com", "testuser");
-    }
-
-    @Test
-    @DisplayName("Should find user by ID successfully")
-    void shouldFindUserById() {
-        // Given
-        when(userRepository.findById(1L)).thenReturn(Optional.of(testUser));
-        when(userMapper.toResponse(testUser)).thenReturn(userResponse);
-
-        // When
-        UserResponse result = userService.findById(1L);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.email()).isEqualTo("test@example.com");
-        verify(userRepository).findById(1L);
-        verify(userMapper).toResponse(testUser);
-    }
-
-    @Test
-    @DisplayName("Should throw exception when user not found")
-    void shouldThrowWhenUserNotFound() {
-        // Given
-        when(userRepository.findById(anyLong())).thenReturn(Optional.empty());
-
-        // When / Then
-        assertThatThrownBy(() -> userService.findById(999L))
-            .isInstanceOf(EntityNotFoundException.class)
-            .hasMessageContaining("User not found");
-
-        verify(userRepository).findById(999L);
-        verifyNoInteractions(userMapper);
-    }
-
-    @Test
-    @DisplayName("Should create user successfully")
-    void shouldCreateUser() {
-        // Given
-        when(userMapper.toEntity(userRequest)).thenReturn(testUser);
-        when(userRepository.save(any(User.class))).thenReturn(testUser);
-        when(userMapper.toResponse(testUser)).thenReturn(userResponse);
-
-        // When
-        UserResponse result = userService.create(userRequest);
-
-        // Then
-        assertThat(result).isNotNull();
-        assertThat(result.id()).isEqualTo(1L);
-        verify(userRepository).save(any(User.class));
-    }
-
-    @ParameterizedTest
-    @ValueSource(strings = {"admin", "user", "moderator"})
-    @DisplayName("Should validate different user roles")
-    void shouldValidateUserRoles(String role) {
-        // Test with multiple roles
-        assertThat(role).isNotBlank();
-    }
-}
-```
-
-## Integration Testing with TestContainers
-
-```java
-package com.example.integration;
-
-import com.example.application.dto.UserRequest;
-import com.example.application.dto.UserResponse;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.boot.test.web.client.TestRestTemplate;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.test.context.DynamicPropertyRegistry;
-import org.springframework.test.context.DynamicPropertySource;
-import org.testcontainers.containers.PostgreSQLContainer;
-import org.testcontainers.junit.jupiter.Container;
-import org.testcontainers.junit.jupiter.Testcontainers;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
-@Testcontainers
-class UserIntegrationTest {
-
-    @Container
-    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine")
-        .withDatabaseName("testdb")
-        .withUsername("test")
-        .withPassword("test");
-
-    @DynamicPropertySource
-    static void configureProperties(DynamicPropertyRegistry registry) {
-        registry.add("spring.datasource.url", postgres::getJdbcUrl);
-        registry.add("spring.datasource.username", postgres::getUsername);
-        registry.add("spring.datasource.password", postgres::getPassword);
-    }
-
-    @Autowired
-    private TestRestTemplate restTemplate;
-
-    @BeforeEach
-    void setUp() {
-        // Clean up database before each test
-    }
-
-    @Test
-    void shouldCreateAndRetrieveUser() {
-        // Create user
-        UserRequest request = new UserRequest("test@example.com", "testuser");
-        ResponseEntity<UserResponse> createResponse = restTemplate.postForEntity(
-            "/api/users",
-            request,
-            UserResponse.class
-        );
-
-        assertThat(createResponse.getStatusCode()).isEqualTo(HttpStatus.CREATED);
-        assertThat(createResponse.getBody()).isNotNull();
-        Long userId = createResponse.getBody().id();
-
-        // Retrieve user
-        ResponseEntity<UserResponse> getResponse = restTemplate.getForEntity(
-            "/api/users/" + userId,
-            UserResponse.class
-        );
-
-        assertThat(getResponse.getStatusCode()).isEqualTo(HttpStatus.OK);
-        assertThat(getResponse.getBody().email()).isEqualTo("test@example.com");
-    }
-}
-```
-
-## Repository Testing
-
-```java
-package com.example.domain.repository;
-
-import com.example.domain.model.User;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
-import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
-import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
-import org.testcontainers.containers.PostgreSQLContainer;
-import org.testcontainers.junit.jupiter.Container;
-import org.testcontainers.junit.jupiter.Testcontainers;
-
-import java.util.Optional;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-@DataJpaTest
-@Testcontainers
-@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
-class UserRepositoryTest {
-
-    @Container
-    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:16-alpine");
-
-    @Autowired
-    private TestEntityManager entityManager;
-
-    @Autowired
-    private UserRepository userRepository;
-
-    @Test
-    void shouldFindUserByEmail() {
-        // Given
-        User user = User.builder()
-            .email("test@example.com")
-            .username("testuser")
-            .active(true)
-            .build();
-        entityManager.persistAndFlush(user);
-
-        // When
-        Optional<User> found = userRepository.findByEmail("test@example.com");
-
-        // Then
-        assertThat(found).isPresent();
-        assertThat(found.get().getEmail()).isEqualTo("test@example.com");
-    }
-
-    @Test
-    void shouldCountActiveUsers() {
-        // Given
-        User activeUser = User.builder()
-            .email("active@example.com")
-            .username("active")
-            .active(true)
-            .build();
-        User inactiveUser = User.builder()
-            .email("inactive@example.com")
-            .username("inactive")
-            .active(false)
-            .build();
-        entityManager.persist(activeUser);
-        entityManager.persist(inactiveUser);
-        entityManager.flush();
-
-        // When
-        long count = userRepository.countByActiveTrue();
-
-        // Then
-        assertThat(count).isEqualTo(1);
-    }
-}
-```
-
-## REST Controller Testing
-
-```java
-package com.example.presentation.rest;
-
-import com.example.application.dto.UserRequest;
-import com.example.application.dto.UserResponse;
-import com.example.application.service.UserService;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
-import org.springframework.boot.test.mock.mockito.MockBean;
-import org.springframework.http.MediaType;
-import org.springframework.security.test.context.support.WithMockUser;
-import org.springframework.test.web.servlet.MockMvc;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.Mockito.when;
-import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.csrf;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-
-@WebMvcTest(UserController.class)
-class UserControllerTest {
-
-    @Autowired
-    private MockMvc mockMvc;
-
-    @Autowired
-    private ObjectMapper objectMapper;
-
-    @MockBean
-    private UserService userService;
-
-    @Test
-    @WithMockUser
-    void shouldGetUserById() throws Exception {
-        // Given
-        UserResponse response = new UserResponse(1L, "test@example.com", "testuser");
-        when(userService.findById(1L)).thenReturn(response);
-
-        // When / Then
-        mockMvc.perform(get("/api/users/1"))
-            .andExpect(status().isOk())
-            .andExpect(jsonPath("$.id").value(1))
-            .andExpect(jsonPath("$.email").value("test@example.com"));
-    }
-
-    @Test
-    @WithMockUser
-    void shouldCreateUser() throws Exception {
-        // Given
-        UserRequest request = new UserRequest("test@example.com", "testuser");
-        UserResponse response = new UserResponse(1L, "test@example.com", "testuser");
-        when(userService.create(any(UserRequest.class))).thenReturn(response);
-
-        // When / Then
-        mockMvc.perform(post("/api/users")
-                .with(csrf())
-                .contentType(MediaType.APPLICATION_JSON)
-                .content(objectMapper.writeValueAsString(request)))
-            .andExpect(status().isCreated())
-            .andExpect(jsonPath("$.id").value(1));
-    }
-
-    @Test
-    void shouldReturn401WhenNotAuthenticated() throws Exception {
-        mockMvc.perform(get("/api/users/1"))
-            .andExpect(status().isUnauthorized());
-    }
-}
-```
-
-## Test Configuration
-
-```java
-package com.example.config;
-
-import org.springframework.boot.test.context.TestConfiguration;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Primary;
-import org.springframework.security.crypto.password.NoOpPasswordEncoder;
-import org.springframework.security.crypto.password.PasswordEncoder;
-
-@TestConfiguration
-public class TestSecurityConfig {
-
-    @Bean
-    @Primary
-    public PasswordEncoder passwordEncoder() {
-        return NoOpPasswordEncoder.getInstance();
-    }
-}
-```
-
-## Test Data Builders
-
-```java
-package com.example.test.builders;
-
-import com.example.domain.model.User;
-
-public class UserTestBuilder {
-
-    private Long id = 1L;
-    private String email = "test@example.com";
-    private String username = "testuser";
-    private Boolean active = true;
-
-    public static UserTestBuilder aUser() {
-        return new UserTestBuilder();
-    }
-
-    public UserTestBuilder withId(Long id) {
-        this.id = id;
-        return this;
-    }
-
-    public UserTestBuilder withEmail(String email) {
-        this.email = email;
-        return this;
-    }
-
-    public UserTestBuilder inactive() {
-        this.active = false;
-        return this;
-    }
-
-    public User build() {
-        return User.builder()
-            .id(id)
-            .email(email)
-            .username(username)
-            .active(active)
-            .build();
-    }
-}
-
-// Usage
-User user = aUser()
-    .withEmail("custom@example.com")
-    .inactive()
-    .build();
-```
-
-## Performance Testing with JMH
-
-```java
-package com.example.benchmark;
-
-import org.openjdk.jmh.annotations.*;
-import org.openjdk.jmh.runner.Runner;
-import org.openjdk.jmh.runner.options.Options;
-import org.openjdk.jmh.runner.options.OptionsBuilder;
-
-import java.util.concurrent.TimeUnit;
-
-@BenchmarkMode(Mode.AverageTime)
-@OutputTimeUnit(TimeUnit.MICROSECONDS)
-@State(Scope.Benchmark)
-@Fork(value = 2, warmups = 1)
-@Warmup(iterations = 3)
-@Measurement(iterations = 5)
-public class UserServiceBenchmark {
-
-    private UserService userService;
-
-    @Setup
-    public void setup() {
-        // Initialize test data
-        userService = new UserService();
-    }
-
-    @Benchmark
-    public void benchmarkFindUser() {
-        userService.findById(1L);
-    }
-
-    public static void main(String[] args) throws Exception {
-        Options opt = new OptionsBuilder()
-            .include(UserServiceBenchmark.class.getSimpleName())
-            .build();
-        new Runner(opt).run();
-    }
-}
-```
-
-## Test Containers Shared Instance
-
-```java
-package com.example.test;
-
-import org.springframework.test.context.DynamicPropertyRegistry;
-import org.springframework.test.context.DynamicPropertySource;
-import org.testcontainers.containers.PostgreSQLContainer;
-
-public abstract class AbstractIntegrationTest {
-
-    static final PostgreSQLContainer<?> postgres;
-
-    static {
-        postgres = new PostgreSQLContainer<>("postgres:16-alpine")
-            .withReuse(true);
-        postgres.start();
-    }
-
-    @DynamicPropertySource
-    static void configureProperties(DynamicPropertyRegistry registry) {
-        registry.add("spring.datasource.url", postgres::getJdbcUrl);
-        registry.add("spring.datasource.username", postgres::getUsername);
-        registry.add("spring.datasource.password", postgres::getPassword);
-    }
-}
-```
-
-## Quick Reference
-
-| Annotation | Purpose |
-|-----------|---------|
-| `@Test` | Mark test method |
-| `@BeforeEach` | Run before each test |
-| `@AfterEach` | Run after each test |
-| `@DisplayName` | Readable test name |
-| `@ParameterizedTest` | Data-driven tests |
-| `@ExtendWith` | Register extensions |
-| `@SpringBootTest` | Full application context |
-| `@WebMvcTest` | Test MVC layer only |
-| `@DataJpaTest` | Test repository layer |
-| `@MockBean` | Mock Spring bean |
-| `@WithMockUser` | Mock authenticated user |
-| `assertThat()` | AssertJ fluent assertions |
-| `verify()` | Mockito verification |

package/skills/javascript-pro/SKILL.md

@@ -1,132 +0,0 @@
----
-name: javascript-pro
-description: Writes, debugs, and refactors JavaScript code using modern ES2023+ features, async/await patterns, ESM module systems, and Node.js APIs. Use when building vanilla JavaScript applications, implementing Promise-based async flows, optimising browser or Node.js performance, working with Web Workers or Fetch API, or reviewing .js/.mjs/.cjs files for correctness and best practices.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: language
-  triggers: JavaScript, ES2023, async await, Node.js, vanilla JavaScript, Web Workers, Fetch API, browser API, module system
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: fullstack-guardian
----
-
-# JavaScript Pro
-
-## When to Use This Skill
-
-- Building vanilla JavaScript applications
-- Implementing async/await patterns and Promise handling
-- Working with modern module systems (ESM/CJS)
-- Optimizing browser performance and memory usage
-- Developing Node.js backend services
-- Implementing Web Workers, Service Workers, or browser APIs
-
-## Core Workflow
-
-1. **Analyze requirements** — Review `package.json`, module system, Node version, browser targets; confirm `.js`/`.mjs`/`.cjs` conventions
-2. **Design architecture** — Plan modules, async flows, and error handling strategies
-3. **Implement** — Write ES2023+ code with proper patterns and optimisations
-4. **Validate** — Run linter (`eslint --fix`); if linter fails, fix all reported issues and re-run before proceeding. Check for memory leaks with DevTools or `--inspect`, verify bundle size; if leaks are found, resolve them before continuing
-5. **Test** — Write comprehensive tests with Jest achieving 85%+ coverage; if coverage falls short, add missing cases and re-run. Confirm no unhandled Promise rejections
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Modern Syntax | `references/modern-syntax.md` | ES2023+ features, optional chaining, private fields |
-| Async Patterns | `references/async-patterns.md` | Promises, async/await, error handling, event loop |
-| Modules | `references/modules.md` | ESM vs CJS, dynamic imports, package.json exports |
-| Browser APIs | `references/browser-apis.md` | Fetch, Web Workers, Storage, IntersectionObserver |
-| Node Essentials | `references/node-essentials.md` | fs/promises, streams, EventEmitter, worker threads |
-
-## Constraints
-
-### MUST DO
-- Use ES2023+ features exclusively
-- Use `X | null` or `X | undefined` patterns
-- Use optional chaining (`?.`) and nullish coalescing (`??`)
-- Use async/await for all asynchronous operations
-- Use ESM (`import`/`export`) for new projects
-- Implement proper error handling with try/catch
-- Add JSDoc comments for complex functions
-- Follow functional programming principles
-
-### MUST NOT DO
-- Use `var` (always use `const` or `let`)
-- Use callback-based patterns (prefer Promises)
-- Mix CommonJS and ESM in the same module
-- Ignore memory leaks or performance issues
-- Skip error handling in async functions
-- Use synchronous I/O in Node.js
-- Mutate function parameters
-- Create blocking operations in the browser
-
-## Key Patterns with Examples
-
-### Async/Await Error Handling
-```js
-// ✅ Correct — always handle async errors explicitly
-async function fetchUser(id) {
-  try {
-    const response = await fetch(`/api/users/${id}`);
-    if (!response.ok) throw new Error(`HTTP ${response.status}`);
-    return await response.json();
-  } catch (err) {
-    console.error("fetchUser failed:", err);
-    return null;
-  }
-}
-
-// ❌ Incorrect — unhandled rejection, no null guard
-async function fetchUser(id) {
-  const response = await fetch(`/api/users/${id}`);
-  return response.json();
-}
-```
-
-### Optional Chaining & Nullish Coalescing
-```js
-// ✅ Correct
-const city = user?.address?.city ?? "Unknown";
-
-// ❌ Incorrect — throws if address is undefined
-const city = user.address.city || "Unknown";
-```
-
-### ESM Module Structure
-```js
-// ✅ Correct — named exports, no default-only exports for libraries
-// utils/math.mjs
-export const add = (a, b) => a + b;
-export const multiply = (a, b) => a * b;
-
-// consumer.mjs
-import { add } from "./utils/math.mjs";
-
-// ❌ Incorrect — mixing require() with ESM
-const { add } = require("./utils/math.mjs");
-```
-
-### Avoid var / Prefer const
-```js
-// ✅ Correct
-const MAX_RETRIES = 3;
-let attempts = 0;
-
-// ❌ Incorrect
-var MAX_RETRIES = 3;
-var attempts = 0;
-```
-
-## Output Templates
-
-When implementing JavaScript features, provide:
-1. Module file with clean exports
-2. Test file with comprehensive coverage
-3. JSDoc documentation for public APIs
-4. Brief explanation of patterns used