@alanwang-merit/meritdata-platform-skill-package 1.0.10 → 1.0.12

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/java-coding-standards/SKILL.md

@@ -1,147 +0,0 @@
----
-name: java-coding-standards
-description: "Spring Boot服务的Java编码标准：命名、不可变性、Optional用法、流、异常、泛型和项目布局。"
-origin: ECC
----
-
-# Java 编码规范
-
-适用于 Spring Boot 服务中可读、可维护的 Java (17+) 代码的规范。
-
-## 何时激活
-
-* 在 Spring Boot 项目中编写或审查 Java 代码时
-* 强制执行命名、不可变性或异常处理约定时
-* 使用记录类、密封类或模式匹配（Java 17+）时
-* 审查 Optional、流或泛型的使用时
-* 构建包和项目布局时
-
-## 核心原则
-
-* 清晰优于巧妙
-* 默认不可变；最小化共享可变状态
-* 快速失败并提供有意义的异常
-* 一致的命名和包结构
-
-## 命名
-
-```java
-// PASS: Classes/Records: PascalCase
-public class MarketService {}
-public record Money(BigDecimal amount, Currency currency) {}
-
-// PASS: Methods/fields: camelCase
-private final MarketRepository marketRepository;
-public Market findBySlug(String slug) {}
-
-// PASS: Constants: UPPER_SNAKE_CASE
-private static final int MAX_PAGE_SIZE = 100;
-```
-
-## 不可变性
-
-```java
-// PASS: Favor records and final fields
-public record MarketDto(Long id, String name, MarketStatus status) {}
-
-public class Market {
-  private final Long id;
-  private final String name;
-  // getters only, no setters
-}
-```
-
-## Optional 使用
-
-```java
-// PASS: Return Optional from find* methods
-Optional<Market> market = marketRepository.findBySlug(slug);
-
-// PASS: Map/flatMap instead of get()
-return market
-    .map(MarketResponse::from)
-    .orElseThrow(() -> new EntityNotFoundException("Market not found"));
-```
-
-## Streams 最佳实践
-
-```java
-// PASS: Use streams for transformations, keep pipelines short
-List<String> names = markets.stream()
-    .map(Market::name)
-    .filter(Objects::nonNull)
-    .toList();
-
-// FAIL: Avoid complex nested streams; prefer loops for clarity
-```
-
-## 异常
-
-* 领域错误使用非受检异常；包装技术异常时提供上下文
-* 创建特定领域的异常（例如，`MarketNotFoundException`）
-* 避免宽泛的 `catch (Exception ex)`，除非在中心位置重新抛出/记录
-
-```java
-throw new MarketNotFoundException(slug);
-```
-
-## 泛型和类型安全
-
-* 避免原始类型；声明泛型参数
-* 对于可复用的工具类，优先使用有界泛型
-
-```java
-public <T extends Identifiable> Map<Long, T> indexById(Collection<T> items) { ... }
-```
-
-## 项目结构 (Maven/Gradle)
-
-```
-src/main/java/com/example/app/
-  config/
-  controller/
-  service/
-  repository/
-  domain/
-  dto/
-  util/
-src/main/resources/
-  application.yml
-src/test/java/... (mirrors main)
-```
-
-## 格式化和风格
-
-* 一致地使用 2 或 4 个空格（项目标准）
-* 每个文件一个公共顶级类型
-* 保持方法简短且专注；提取辅助方法
-* 成员顺序：常量、字段、构造函数、公共方法、受保护方法、私有方法
-
-## 需要避免的代码坏味道
-
-* 长参数列表 → 使用 DTO/构建器
-* 深度嵌套 → 提前返回
-* 魔法数字 → 命名常量
-* 静态可变状态 → 优先使用依赖注入
-* 静默捕获块 → 记录日志并处理或重新抛出
-
-## 日志记录
-
-```java
-private static final Logger log = LoggerFactory.getLogger(MarketService.class);
-log.info("fetch_market slug={}", slug);
-log.error("failed_fetch_market slug={}", slug, ex);
-```
-
-## Null 处理
-
-* 仅在不可避免时接受 `@Nullable`；否则使用 `@NonNull`
-* 在输入上使用 Bean 验证（`@NotNull`, `@NotBlank`）
-
-## 测试期望
-
-* 使用 JUnit 5 + AssertJ 进行流畅的断言
-* 使用 Mockito 进行模拟；尽可能避免部分模拟
-* 倾向于确定性测试；没有隐藏的休眠
-
-**记住**：保持代码意图明确、类型安全且可观察。除非证明有必要，否则优先考虑可维护性而非微优化。

package/skills/java-testing/SKILL.md

@@ -1,34 +0,0 @@
----
-name: java-testing
-description: 'Testing standards using JUnit 5, AssertJ, and Mockito for Java. Use when writing or reviewing Java unit tests, setting up parameterized tests, writing integration tests with Testcontainers, or working with Mockito mocks. (triggers: **/*Test.java, **/*IT.java, @Test, @ParameterizedTest, Mockito, AssertJ, assertThat, JUnit, Testcontainers)'
----
-
-# Java Testing Standards
-
-## **Priority: P0 (CRITICAL)**
-
-High-reliability testing using JUnit 5 and fluent assertions.
-
-## Implementation Guidelines
-
-- **JUnit 5 (Jupiter)**: Use **`@Test`**, **`@BeforeEach`**, and **`@AfterEach`**. Avoid JUnit 4 classes.
-- **Fluent Assertions**: Use **`AssertJ (assertThat)`** over JUnit `assertEquals` — enhanced readability.
-- **Naming**: Use **`MethodName_State_Result`** or **`@DisplayName("Check if X when Y")`**.
-- **Parameterized Tests**: Use **`@ParameterizedTest`** with **`@ValueSource`**, **`@CsvSource`**, or **`@MethodSource`**.
-- **Mocking Strategy**: Use **`Mockito`** with `@ExtendWith(MockitoExtension.class)` (JUnit 5). Use **`@Mock`**, **`@Spy`**, and **`@InjectMocks`**. NEVER mock data-only Records.
-- **Integration Testing**: Use **`Testcontainers`** with `@Container` annotation for real databases (PostgreSQL/Redis) in integration tests (`*IT.java`).
-- **Isolation**: Each test method MUST be isolated and independent; use **`@DirtiesContext`** sparingly.
-- **AssertJ Chaining**: Chain assertions for clarity: **`assertThat(result).isNotNull().hasSize(2).contains("X")`**.
-- **Mocking verification**: Use **`verify(mock, times(1)).method()`** to audit side-effects.
-- **Exceptions**: Use **`assertThatThrownBy(() -> ...)`** to verify specific Exception types and messages.
-
-## Anti-Patterns
-
-- **No Logic in Tests**: Keep tests declarative; no loops or if/else branching.
-- **No System.out in Tests**: Use assertions; never print to stdout.
-- **No Legacy Assertions**: Use `assertThat(a).isEqualTo(b)`, not `assertTrue(a == b)`.
-- **No Shared State**: Tests must be isolated and order-independent.
-
-## References
-
-- [Full JUnit 5 + Mockito + AssertJ Template](references/junit-template.md)