page = jobService.searchJobs(null, city, null, null, null, null, "latest", 0, 10);
+
+ assertThat(page.getContent()).hasSize(1);
+ JobSearchItem item = page.getContent().get(0);
+ assertThat(item.getId()).isEqualTo(jobId);
+ assertThat(item.getCompany()).as("企业信息由真实 CompanyRepository 批量组装").isNotNull();
+ assertThat(item.getCompany().getId()).isEqualTo(companyA);
+ assertThat(item.getCompany().getName()).isEqualTo(tag + "公司甲");
+ assertThat(item.getCompany().getVerified()).isTrue();
+ }
+
+ @Test
+ void searchDoesNotReturnDraftOrClosedJobs() {
+ String city = tag + "STATUS";
+ Long published = publishedJob(companyA, city, "FULL_TIME", 10000, 20000);
+ jobWithStatus(companyA, city, JobStatus.DRAFT.name());
+ jobWithStatus(companyA, city, JobStatus.CLOSED.name());
+
+ for (String sort : new String[]{"latest", "relevance", "salary", null}) {
+ assertThat(ids(jobService.searchJobs(null, city, null, null, null, null, sort, 0, 10)))
+ .as("非 PUBLISHED 岗位绝不进入公开搜索（sort=" + sort + "）")
+ .containsExactly(published);
+ }
+ }
+}
diff --git a/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchServiceTest.java b/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchServiceTest.java
index 7f910ae..1325c2b 100644
--- a/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchServiceTest.java
+++ b/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchServiceTest.java
@@ -28,6 +28,19 @@ import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;
+/**
+ * {@link JobService#searchJobs} 的**编排与参数校验**测试（纯 Mockito）。
+ *
+ * 本类把 {@code JobRepository.findAll(Specification, Pageable)} 与
+ * {@code CompanyRepository} 整体 Mock 掉，因此它只能证明参数校验、分页对象、
+ * 排序参数传递和 DTO 组装的编排逻辑；**不能证明 Criteria 谓词、SQL 过滤、
+ * 排序与分页在真实数据库上的行为**。
+ *
+ * 真实查询覆盖见 Q01 补充的
+ * {@link JobSearchSpecificationIntegrationTest}（H2 真实 Repository）、
+ * {@link JobSearchServiceIntegrationTest}（H2 真实 Service/EntityManager）、
+ * {@link JobSearchSpecificationMySqlIntegrationTest}（真实 MySQL 8）。
+ */
@ExtendWith(MockitoExtension.class)
class JobSearchServiceTest {
diff --git a/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchSpecificationIntegrationTest.java b/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchSpecificationIntegrationTest.java
new file mode 100644
index 0000000..f0b6a55
--- /dev/null
+++ b/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchSpecificationIntegrationTest.java
@@ -0,0 +1,425 @@
+package com.mydreamjob.job;
+
+import com.mydreamjob.auth.User;
+import com.mydreamjob.auth.UserRepository;
+import com.mydreamjob.company.Company;
+import com.mydreamjob.company.CompanyRepository;
+import org.junit.jupiter.api.AfterEach;
+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.mock.mockito.MockBean;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ActiveProfiles;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Q01：{@link JobSearchSpecification} 的**真实数据库**覆盖（H2 + 真实 Flyway + 真实 JobRepository）。
+ *
+ * 与 {@code JobSearchServiceTest} 的区别：这里不 Mock Repository / Specification /
+ * EntityManager / 事务，直接执行 {@code jobRepository.findAll(spec, pageable)}，
+ * 断言返回的**ID 及顺序**，从而真正验证 Criteria 谓词、过滤与排序。
+ *
+ * 夹具隔离：每个用例使用唯一城市标记，只在自己的数据上断言，不依赖种子岗位。
+ */
+@SpringBootTest
+@ActiveProfiles("integration-test")
+class JobSearchSpecificationIntegrationTest {
+
+ private static final AtomicLong SEQ = new AtomicLong(71000);
+ /** 结果集足够大，避免分页测试被默认 size 截断。 */
+ private static final int MAX_RESULTS = 50;
+
+ @MockBean
+ private RedisTemplate redisTemplate;
+
+ @Autowired private JobRepository jobRepository;
+ @Autowired private CompanyRepository companyRepository;
+ @Autowired private UserRepository userRepository;
+ @Autowired private JdbcTemplate jdbcTemplate;
+
+ private final List jobIds = new ArrayList<>();
+ private final List companyIds = new ArrayList<>();
+ private final List userIds = new ArrayList<>();
+
+ private String tag;
+ private Long companyA;
+ private Long companyB;
+
+ @BeforeEach
+ void setUp() {
+ tag = "Q01" + SEQ.incrementAndGet();
+ companyA = createCompany("甲");
+ companyB = createCompany("乙");
+ }
+
+ @AfterEach
+ void tearDown() {
+ // FK 安全顺序：jobs -> companies -> users
+ if (!jobIds.isEmpty()) {
+ jobRepository.deleteAllById(jobIds);
+ }
+ if (!companyIds.isEmpty()) {
+ companyRepository.deleteAllById(companyIds);
+ }
+ if (!userIds.isEmpty()) {
+ userRepository.deleteAllById(userIds);
+ }
+ jobIds.clear();
+ companyIds.clear();
+ userIds.clear();
+ }
+
+ // ── 夹具 ────────────────────────────────────────────────────
+
+ private Long createCompany(String label) {
+ Long ownerId = userRepository.save(User.builder()
+ .phone("18" + String.format("%09d", SEQ.incrementAndGet()))
+ .nickname(tag + "-" + label)
+ .role(User.Role.COMPANY)
+ .roles(Set.of(User.Role.COMPANY))
+ .active(true).verified(true).build()).getId();
+ userIds.add(ownerId);
+ Long id = companyRepository.save(Company.builder()
+ .ownerUserId(ownerId).name(tag + "公司" + label).verified(true).build()).getId();
+ companyIds.add(id);
+ return id;
+ }
+
+ private Long job(Long companyId, String title, String description, String requirements,
+ String city, String employmentType, Integer salaryMin, Integer salaryMax, String status) {
+ Long id = jobRepository.save(Job.builder()
+ .companyId(companyId)
+ .title(title)
+ .description(description)
+ .requirements(requirements)
+ .city(city)
+ .employmentType(employmentType)
+ .salaryMin(salaryMin)
+ .salaryMax(salaryMax)
+ .status(status)
+ .build()).getId();
+ jobIds.add(id);
+ return id;
+ }
+
+ private Long publishedJob(Long companyId, String title, String description, String requirements,
+ String city, String employmentType, Integer salaryMin, Integer salaryMax) {
+ return job(companyId, title, description, requirements, city, employmentType,
+ salaryMin, salaryMax, JobStatus.PUBLISHED.name());
+ }
+
+ /**
+ * 回写 createdAt：实体的 {@code @CreatedDate} 审计会在持久化时覆盖显式值，
+ * 排序用例需要精确时间，因此用原生 SQL 回写（不经过审计）。
+ */
+ private void setCreatedAt(Long jobId, LocalDateTime createdAt) {
+ jdbcTemplate.update("UPDATE jobs SET created_at = ? WHERE id = ?", createdAt, jobId);
+ }
+
+ /** 与服务一致的 latest 排序：createdAt DESC, id DESC。 */
+ private Pageable latest( int size) {
+ return PageRequest.of(0, size,
+ Sort.by(new Sort.Order(Sort.Direction.DESC, "createdAt"),
+ new Sort.Order(Sort.Direction.DESC, "id")));
+ }
+
+ private List searchIds(String keyword, String city, String employmentType,
+ Integer salaryMin, Integer salaryMax, Long companyId) {
+ return jobRepository.findAll(
+ JobSearchSpecification.searchJobs(keyword, city, employmentType, salaryMin, salaryMax, companyId),
+ latest(MAX_RESULTS))
+ .getContent().stream().map(Job::getId).toList();
+ }
+
+ // ── keyword：三个字段 ───────────────────────────────────────
+
+ @Test
+ void keywordMatchesTitle() {
+ String city = tag + "CITY_TITLE";
+ Long inTitle = publishedJob(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ // 其余两个字段均不含 "Java"，确保命中的是 title
+ publishedJob(companyA, "无关岗位", "无关描述", "无关要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds("Java", city, null, null, null, null)).containsExactly(inTitle);
+ }
+
+ @Test
+ void keywordMatchesDescription() {
+ String city = tag + "CITY_DESC";
+ Long inDesc = publishedJob(companyA, "岗位", tag + "负责Java后端开发", "要求", city, "FULL_TIME", 10000, 20000);
+ publishedJob(companyA, "岗位", "无关描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds("Java", city, null, null, null, null)).containsExactly(inDesc);
+ }
+
+ @Test
+ void keywordMatchesRequirements() {
+ String city = tag + "CITY_REQ";
+ Long inReq = publishedJob(companyA, "岗位", "描述", tag + "熟悉Java", city, "FULL_TIME", 10000, 20000);
+ publishedJob(companyA, "岗位", "描述", "无关要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds("Java", city, null, null, null, null)).containsExactly(inReq);
+ }
+
+ @Test
+ void keywordIsCaseInsensitive() {
+ String city = tag + "CITY_CASE";
+ Long lower = publishedJob(companyA, tag + "java开发", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long upper = publishedJob(companyA, tag + "JAVA开发", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds("java", city, null, null, null, null))
+ .containsExactlyInAnyOrder(lower, upper);
+ assertThat(searchIds("JaVa", city, null, null, null, null))
+ .containsExactlyInAnyOrder(lower, upper);
+ }
+
+ @Test
+ void nullBlankAndWhitespaceKeywordDoNotFilter() {
+ String city = tag + "CITY_NOKW";
+ Long a = publishedJob(companyA, tag + "甲岗", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long b = publishedJob(companyA, tag + "乙岗", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ for (String blank : new String[]{null, "", " ", " ", "\t"}) {
+ assertThat(searchIds(blank, city, null, null, null, null))
+ .as("blank keyword 不应参与过滤：" + blank)
+ .containsExactlyInAnyOrder(a, b);
+ }
+ }
+
+ @Test
+ void keywordIsTrimmed() {
+ String city = tag + "CITY_TRIM";
+ Long target = publishedJob(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(" Java ", city, null, null, null, null)).containsExactly(target);
+ }
+
+ // ── city / employmentType / companyId ──────────────────────
+
+ @Test
+ void cityUsesTrimmedExactMatch() {
+ String city = tag + "CITY_EXACT";
+ Long target = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ publishedJob(companyA, "岗位", "描述", "要求", city + "别处", "FULL_TIME", 10000, 20000);
+
+ // 精确匹配：前缀相同但不同的城市不得命中
+ assertThat(searchIds(null, city, null, null, null, null)).containsExactly(target);
+ // trim 后精确匹配
+ assertThat(searchIds(null, " " + city + " ", null, null, null, null)).containsExactly(target);
+ }
+
+ @Test
+ void cityCaseVariantHasSameResultAcrossDatabases() {
+ String city = tag + "-Beijing";
+ Long target = publishedJob(companyA, "岗位", "描述", "要求", city,
+ "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(null, city.toLowerCase(), null, null, null, null))
+ .containsExactly(target);
+ assertThat(searchIds(null, " " + city.toLowerCase() + " ", null, null, null, null))
+ .containsExactly(target);
+ }
+
+ @Test
+ void employmentTypeUsesTrimmedExactMatch() {
+ String city = tag + "CITY_ET";
+ Long full = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ publishedJob(companyA, "岗位", "描述", "要求", city, "PART_TIME", 10000, 20000);
+
+ assertThat(searchIds(null, city, "FULL_TIME", null, null, null)).containsExactly(full);
+ assertThat(searchIds(null, city, " FULL_TIME ", null, null, null)).containsExactly(full);
+ // 精确匹配：不得做前缀匹配
+ assertThat(searchIds(null, city, "FULL", null, null, null)).isEmpty();
+ }
+
+ @Test
+ void employmentTypeCaseVariantHasSameResultAcrossDatabases() {
+ String city = tag + "CITY_EMP_CASE";
+ Long target = publishedJob(companyA, "岗位", "描述", "要求", city,
+ "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(null, city, "full_time", null, null, null)).containsExactly(target);
+ assertThat(searchIds(null, city, " full_time ", null, null, null)).containsExactly(target);
+ }
+
+ @Test
+ void companyIdFiltersExactly() {
+ String city = tag + "CITY_COMPANY";
+ Long mine = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ publishedJob(companyB, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(null, city, null, null, null, companyA)).containsExactly(mine);
+ }
+
+ // ── 薪资：区间重叠语义 ──────────────────────────────────────
+
+ @Test
+ void salaryMinMatchesWhenJobMaximumEqualsBoundary() {
+ String city = tag + "CITY_SMIN";
+ // 岗位 salaryMax 恰好等于用户 salaryMin
+ Long boundary = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 19999);
+
+ assertThat(searchIds(null, city, null, 20000, null, null)).containsExactly(boundary);
+ }
+
+ @Test
+ void salaryMaxMatchesWhenJobMinimumEqualsBoundary() {
+ String city = tag + "CITY_SMAX";
+ // 岗位 salaryMin 恰好等于用户 salaryMax
+ Long boundary = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10001, 20000);
+
+ assertThat(searchIds(null, city, null, null, 10000, null)).containsExactly(boundary);
+ }
+
+ @Test
+ void salaryRangesUseOverlapSemantics() {
+ String city = tag + "CITY_OVERLAP";
+ // 岗位区间 [10k,20k] 与用户区间 [15k,25k] 部分重叠 —— 必须命中
+ Long overlapping = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ // 岗位区间完全包含用户区间 —— 必须命中
+ Long containing = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 12000, 30000);
+
+ assertThat(searchIds(null, city, null, 15000, 25000, null))
+ .containsExactlyInAnyOrder(overlapping, containing);
+ }
+
+ @Test
+ void nonOverlappingSalaryRangeIsExcluded() {
+ String city = tag + "CITY_NOOVERLAP";
+ Long tooLow = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 5000, 9000);
+ Long inRange = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 15000, 25000);
+ Long tooHigh = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 40000, 60000);
+
+ assertThat(searchIds(null, city, null, 10000, 30000, null))
+ .as("只有区间重叠的岗位命中")
+ .containsExactly(inRange);
+ }
+
+ @Test
+ void nullSalaryFieldsFollowExistingContract() {
+ String city = tag + "CITY_NULLSAL";
+ Long bothNull = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", null, null);
+ Long onlyMin = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, null);
+ Long both = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ // 不加薪资条件时，NULL 薪资岗位必须照常返回
+ assertThat(searchIds(null, city, null, null, null, null))
+ .containsExactlyInAnyOrder(bothNull, onlyMin, both);
+
+ // 加了 salaryMin 条件后：`job.salaryMax >= 5000` 对 NULL 求值为 UNKNOWN，
+ // 因此 salaryMax 为 NULL 的两个岗位都被排除，只余 salaryMax 非空且达标的岗位。
+ // 这是 SQL 三值逻辑的既有契约，Q01 锁定该行为、不做修改。
+ assertThat(searchIds(null, city, null, 5000, null, null)).containsExactly(both);
+ }
+
+ // ── 多条件 AND / 状态 ───────────────────────────────────────
+
+ @Test
+ void multipleConditionsUseAndSemantics() {
+ String city = tag + "CITY_AND";
+ Long match = publishedJob(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ // 关键词命中但城市不符
+ publishedJob(companyA, tag + "Java工程师", "描述", "要求", city + "X", "FULL_TIME", 10000, 20000);
+ // 城市命中但用工类型不符
+ publishedJob(companyA, tag + "Java工程师", "描述", "要求", city, "PART_TIME", 10000, 20000);
+ // 公司不符
+ publishedJob(companyB, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ // 薪资不重叠
+ publishedJob(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 90000, 99000);
+
+ assertThat(searchIds("Java", city, "FULL_TIME", 15000, 25000, companyA)).containsExactly(match);
+ }
+
+ @Test
+ void nonPublishedJobsAreAlwaysExcluded() {
+ String city = tag + "CITY_STATUS";
+ Long published = publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ job(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000, JobStatus.DRAFT.name());
+ job(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000, JobStatus.CLOSED.name());
+
+ assertThat(searchIds(null, city, null, null, null, null)).containsExactly(published);
+ // 即使显式按公司过滤，非公开岗位也不得出现
+ assertThat(searchIds(null, city, null, null, null, companyA)).containsExactly(published);
+ }
+
+ // ── 特殊字符 / 分页 / 空结果 ────────────────────────────────
+
+ @Test
+ void specialLikeCharactersFollowExistingContract() {
+ String city = tag + "CITY_LIKE";
+ Long plain = publishedJob(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long percent = publishedJob(companyA, tag + "100%远程", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long underscore = publishedJob(companyA, tag + "A_B岗", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ // 锁定当前契约：keyword 直接拼进 LIKE，% 与 _ 仍作通配符（未转义）。
+ // 这是既有行为，Q01 不改语义，仅在真实库上固定它。
+ assertThat(searchIds("%", city, null, null, null, null))
+ .as("% 作为通配符：命中该城市下全部带标题的岗位")
+ .containsExactlyInAnyOrder(plain, percent, underscore);
+ assertThat(searchIds("_", city, null, null, null, null))
+ .as("_ 作为单字符通配符：命中标题含任意单字符的岗位")
+ .containsExactlyInAnyOrder(plain, percent, underscore);
+ assertThat(searchIds("A_B", city, null, null, null, null))
+ .as("A_B 以通配符解释，可命中 A_B 本身")
+ .containsExactly(underscore);
+ assertThat(searchIds("Java", city, null, null, null, null)).containsExactly(plain);
+ }
+
+ @Test
+ void paginationReturnsStableOrderedIds() {
+ String city = tag + "CITY_PAGE";
+ LocalDateTime base = LocalDateTime.of(2026, 1, 1, 0, 0);
+ List ids = new ArrayList<>();
+ for (int i = 0; i < 5; i++) {
+ Long id = publishedJob(companyA, "岗位" + i, "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ setCreatedAt(id, base.plusDays(i)); // 越大越新
+ ids.add(id);
+ }
+ // 期望顺序：createdAt DESC（越新越前）
+ List expected = new ArrayList<>(ids);
+ java.util.Collections.reverse(expected);
+
+ Pageable first = PageRequest.of(0, 2,
+ Sort.by(new Sort.Order(Sort.Direction.DESC, "createdAt"), new Sort.Order(Sort.Direction.DESC, "id")));
+ Pageable second = PageRequest.of(1, 2,
+ Sort.by(new Sort.Order(Sort.Direction.DESC, "createdAt"), new Sort.Order(Sort.Direction.DESC, "id")));
+
+ var spec = JobSearchSpecification.searchJobs(null, city, null, null, null, null);
+ var page0 = jobRepository.findAll(spec, first);
+ var page1 = jobRepository.findAll(spec, second);
+
+ assertThat(page0.getContent().stream().map(Job::getId).toList())
+ .as("第 0 页按 createdAt DESC 稳定排序").containsExactlyElementsOf(expected.subList(0, 2));
+ assertThat(page1.getContent().stream().map(Job::getId).toList())
+ .as("第 1 页继续按同一顺序，不重复不丢行").containsExactlyElementsOf(expected.subList(2, 4));
+ assertThat(page0.getTotalElements()).as("total 为全部匹配行数").isEqualTo(5);
+ assertThat(page0.getTotalPages()).isEqualTo(3);
+ }
+
+ @Test
+ void noResultReturnsEmptyPage() {
+ String city = tag + "CITY_EMPTY";
+ publishedJob(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ var spec = JobSearchSpecification.searchJobs(tag + "不存在的关键词XYZ", city, null, null, null, null);
+ var page = jobRepository.findAll(spec, latest(MAX_RESULTS));
+
+ assertThat(page.getContent()).isEmpty();
+ assertThat(page.getTotalElements()).isZero();
+ }
+}
diff --git a/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchSpecificationMySqlIntegrationTest.java b/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchSpecificationMySqlIntegrationTest.java
new file mode 100644
index 0000000..4657999
--- /dev/null
+++ b/mydreamjob-server/src/test/java/com/mydreamjob/job/JobSearchSpecificationMySqlIntegrationTest.java
@@ -0,0 +1,384 @@
+package com.mydreamjob.job;
+
+import com.mydreamjob.auth.User;
+import com.mydreamjob.auth.UserRepository;
+import com.mydreamjob.company.Company;
+import com.mydreamjob.company.CompanyRepository;
+import org.junit.jupiter.api.AfterEach;
+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.mock.mockito.MockBean;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.springframework.test.annotation.DirtiesContext;
+import org.testcontainers.containers.MySQLContainer;
+import org.testcontainers.junit.jupiter.Container;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Q01：{@link JobSearchSpecification} 在**真实 MySQL 8** 上的行为对账。
+ *
+ * 使用 Testcontainers 启动独立 MySQL（不复用开发库），执行正式 Flyway 迁移并以
+ * {@code ddl-auto=validate} 启动，重点对账 H2 难以覆盖的差异：大小写比较规则、
+ * LIKE 特殊字符、NULL 排序、边界比较与分页稳定性。
+ *
+ * 不打印任何数据库凭据。Docker 不可用时环境性跳过（{@code disabledWithoutDocker}），
+ * 但独立验收必须显式运行本类并得到 Tests run > 0、Skipped = 0。
+ */
+@Testcontainers(disabledWithoutDocker = true)
+@SpringBootTest
+@ActiveProfiles("mysql-it")
+@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
+class JobSearchSpecificationMySqlIntegrationTest {
+
+ private static final AtomicLong SEQ = new AtomicLong(73000);
+ private static final int MAX_RESULTS = 50;
+
+ @Container
+ static final MySQLContainer MYSQL = new MySQLContainer<>("mysql:8.4")
+ .withDatabaseName("mydreamjob_q01")
+ .withUsername("q01")
+ .withPassword("q01-test-only");
+
+ /**
+ * 连接参数全部来自容器，运行期注入，不落盘、不打印密码。
+ * 应用级测试开关与测试密钥由 {@code mysql-it} profile 提供（见
+ * {@code src/test/resources/application-mysql-it.yml}），方言沿用主配置的 MySQLDialect。
+ */
+ @DynamicPropertySource
+ static void datasource(DynamicPropertyRegistry registry) {
+ registry.add("spring.datasource.url", MYSQL::getJdbcUrl);
+ registry.add("spring.datasource.username", MYSQL::getUsername);
+ registry.add("spring.datasource.password", MYSQL::getPassword);
+ registry.add("spring.jpa.hibernate.ddl-auto", () -> "validate");
+ }
+
+ @MockBean
+ private RedisTemplate redisTemplate;
+
+ @Autowired private JobRepository jobRepository;
+ @Autowired private JobService jobService;
+ @Autowired private CompanyRepository companyRepository;
+ @Autowired private UserRepository userRepository;
+ @Autowired private JdbcTemplate jdbcTemplate;
+
+ private final List jobIds = new ArrayList<>();
+ private final List companyIds = new ArrayList<>();
+ private final List userIds = new ArrayList<>();
+
+ private String tag;
+ private Long companyA;
+ private Long companyB;
+
+ @BeforeEach
+ void setUp() {
+ tag = "Q01M" + SEQ.incrementAndGet();
+ companyA = createCompany("甲");
+ companyB = createCompany("乙");
+ }
+
+ @AfterEach
+ void tearDown() {
+ if (!jobIds.isEmpty()) {
+ jobRepository.deleteAllById(jobIds);
+ }
+ if (!companyIds.isEmpty()) {
+ companyRepository.deleteAllById(companyIds);
+ }
+ if (!userIds.isEmpty()) {
+ userRepository.deleteAllById(userIds);
+ }
+ jobIds.clear();
+ companyIds.clear();
+ userIds.clear();
+ }
+
+ private Long createCompany(String label) {
+ Long ownerId = userRepository.save(User.builder()
+ .phone("17" + String.format("%09d", SEQ.incrementAndGet()))
+ .nickname(tag + "-" + label)
+ .role(User.Role.COMPANY)
+ .roles(Set.of(User.Role.COMPANY))
+ .active(true).verified(true).build()).getId();
+ userIds.add(ownerId);
+ Long id = companyRepository.save(Company.builder()
+ .ownerUserId(ownerId).name(tag + "公司" + label).verified(true).build()).getId();
+ companyIds.add(id);
+ return id;
+ }
+
+ private Long job(Long companyId, String title, String description, String requirements,
+ String city, String employmentType, Integer salaryMin, Integer salaryMax, String status) {
+ Long id = jobRepository.save(Job.builder()
+ .companyId(companyId).title(title).description(description).requirements(requirements)
+ .city(city).employmentType(employmentType).salaryMin(salaryMin).salaryMax(salaryMax)
+ .status(status).build()).getId();
+ jobIds.add(id);
+ return id;
+ }
+
+ private Long published(Long companyId, String title, String description, String requirements,
+ String city, String employmentType, Integer salaryMin, Integer salaryMax) {
+ return job(companyId, title, description, requirements, city, employmentType,
+ salaryMin, salaryMax, JobStatus.PUBLISHED.name());
+ }
+
+ private void setCreatedAt(Long jobId, LocalDateTime createdAt) {
+ jdbcTemplate.update("UPDATE jobs SET created_at = ? WHERE id = ?", createdAt, jobId);
+ }
+
+ private Pageable latestSorted() {
+ return PageRequest.of(0, MAX_RESULTS,
+ Sort.by(new Sort.Order(Sort.Direction.DESC, "createdAt"),
+ new Sort.Order(Sort.Direction.DESC, "id")));
+ }
+
+ private List searchIds(String keyword, String city, String employmentType,
+ Integer salaryMin, Integer salaryMax, Long companyId) {
+ return jobRepository.findAll(
+ JobSearchSpecification.searchJobs(keyword, city, employmentType, salaryMin, salaryMax, companyId),
+ latestSorted())
+ .getContent().stream().map(Job::getId).toList();
+ }
+
+ // ── 与 H2 逐项对账的场景 ────────────────────────────────────
+
+ @Test
+ void keywordCaseInsensitiveMatchesThreeFields() {
+ String city = tag + "MYSQL_KW";
+ Long inTitle = published(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long inDesc = published(companyA, "岗位", tag + "负责Java开发", "要求", city, "FULL_TIME", 10000, 20000);
+ Long inReq = published(companyA, "岗位", "描述", tag + "熟悉JAVA", city, "FULL_TIME", 10000, 20000);
+ published(companyA, "无关岗位", "无关描述", "无关要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds("java", city, null, null, null, null))
+ .as("MySQL 下大小写不敏感且覆盖三字段")
+ .containsExactlyInAnyOrder(inTitle, inDesc, inReq);
+ assertThat(searchIds("JaVa", city, null, null, null, null))
+ .containsExactlyInAnyOrder(inTitle, inDesc, inReq);
+ }
+
+ @Test
+ void nullBlankAndWhitespaceKeywordDoNotFilter() {
+ String city = tag + "MYSQL_NOKW";
+ Long a = published(companyA, tag + "甲岗", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long b = published(companyA, tag + "乙岗", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ for (String blank : new String[]{null, "", " ", " ", "\t"}) {
+ assertThat(searchIds(blank, city, null, null, null, null))
+ .as("blank keyword 不应参与过滤：" + blank)
+ .containsExactlyInAnyOrder(a, b);
+ }
+ }
+
+ @Test
+ void keywordIsTrimmed() {
+ String city = tag + "MYSQL_TRIM";
+ Long target = published(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(" Java ", city, null, null, null, null)).containsExactly(target);
+ }
+
+ @Test
+ void specialLikeCharactersFollowExistingContract() {
+ String city = tag + "MYSQL_LIKE";
+ Long plain = published(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long percent = published(companyA, tag + "100%远程", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long underscore = published(companyA, tag + "A_B岗", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ // 锁定既有契约：% 与 _ 未转义，仍作 LIKE 通配符 —— MySQL 与 H2 行为一致。
+ assertThat(searchIds("%", city, null, null, null, null))
+ .containsExactlyInAnyOrder(plain, percent, underscore);
+ assertThat(searchIds("_", city, null, null, null, null))
+ .containsExactlyInAnyOrder(plain, percent, underscore);
+ assertThat(searchIds("A_B", city, null, null, null, null)).containsExactly(underscore);
+ }
+
+ @Test
+ void cityAndEmploymentTypeUseTrimmedExactMatch() {
+ String city = tag + "MYSQL_CITY";
+ Long target = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long otherCity = published(companyA, "岗位", "描述", "要求", city + "别处", "FULL_TIME", 10000, 20000);
+ Long otherType = published(companyA, "岗位", "描述", "要求", city, "PART_TIME", 10000, 20000);
+
+ // 只给 city 条件时，同城的其他用工类型同样必须返回（city 与 employmentType 是两个独立条件）；
+ // 前缀相同但不同的城市不得命中。
+ assertThat(searchIds(null, city, null, null, null, null))
+ .as("city 精确匹配：同城全部命中，前缀相同的 city+别处 不命中")
+ .containsExactly(otherType, target);
+ assertThat(searchIds(null, city, null, null, null, null)).doesNotContain(otherCity);
+ // 两个条件都给出时，trim 后各自精确匹配
+ assertThat(searchIds(null, " " + city + " ", " FULL_TIME ", null, null, null))
+ .containsExactly(target);
+ }
+
+ @Test
+ void cityCaseVariantHasSameResultAcrossDatabases() {
+ String city = tag + "-Beijing";
+ Long target = published(companyA, "岗位", "描述", "要求", city,
+ "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(null, city.toLowerCase(), null, null, null, null))
+ .containsExactly(target);
+ assertThat(searchIds(null, " " + city.toLowerCase() + " ", null, null, null, null))
+ .containsExactly(target);
+ }
+
+ @Test
+ void employmentTypeCaseVariantHasSameResultAcrossDatabases() {
+ String city = tag + "MYSQL_EMP_CASE";
+ Long target = published(companyA, "岗位", "描述", "要求", city,
+ "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(null, city, "full_time", null, null, null)).containsExactly(target);
+ assertThat(searchIds(null, city, " full_time ", null, null, null)).containsExactly(target);
+ }
+
+ @Test
+ void salaryBoundariesUseOverlapSemantics() {
+ String city = tag + "MYSQL_SALARY";
+ Long boundary = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long noOverlapLow = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 5000, 9000);
+ Long noOverlapHigh = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 40000, 60000);
+
+ // 契约是**单边**比较：salaryMin 只约束「岗位 salaryMax >= 用户 salaryMin」，
+ // 因此边界相等必须命中，salaryMax 更高的岗位同样命中，低于边界的才被排除。
+ assertThat(searchIds(null, city, null, 20000, null, null))
+ .as("岗位 salaryMax >= 20000：边界 20000 与 60000 命中，9000 排除")
+ .containsExactly(noOverlapHigh, boundary);
+ assertThat(searchIds(null, city, null, null, 10000, null))
+ .as("岗位 salaryMin <= 10000：边界 10000 与 5000 命中，40000 排除")
+ .containsExactly(noOverlapLow, boundary);
+ // 两端都给出时按区间重叠：部分重叠命中
+ assertThat(searchIds(null, city, null, 15000, 25000, null)).containsExactly(boundary);
+ // 区间不重叠（高于用户区间 / 低于用户区间）必须排除
+ assertThat(searchIds(null, city, null, 30000, 35000, null)).isEmpty();
+ assertThat(searchIds(null, city, null, 1000, 4000, null)).isEmpty();
+ }
+
+ @Test
+ void nullSalaryFieldsFollowExistingContract() {
+ String city = tag + "MYSQL_NULLSAL";
+ Long bothNull = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", null, null);
+ Long onlyMin = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, null);
+ Long both = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ // 不加薪资条件时，NULL 薪资岗位照常返回
+ assertThat(searchIds(null, city, null, null, null, null))
+ .containsExactlyInAnyOrder(bothNull, onlyMin, both);
+
+ // 一旦给出 salaryMin，`job.salaryMax >= ?` 对 NULL 求值为 UNKNOWN，
+ // salaryMax 为 NULL 的两个岗位被排除 —— SQL 三值逻辑的既有契约，Q01 锁定不改。
+ assertThat(searchIds(null, city, null, 5000, null, null)).containsExactly(both);
+ }
+
+ @Test
+ void multipleConditionsUseAndSemantics() {
+ String city = tag + "MYSQL_AND";
+ Long match = published(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ // 关键词命中但城市不符
+ published(companyA, tag + "Java工程师", "描述", "要求", city + "X", "FULL_TIME", 10000, 20000);
+ // 城市命中但用工类型不符
+ published(companyA, tag + "Java工程师", "描述", "要求", city, "PART_TIME", 10000, 20000);
+ // 公司不符
+ published(companyB, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ // 薪资不重叠
+ published(companyA, tag + "Java工程师", "描述", "要求", city, "FULL_TIME", 90000, 99000);
+
+ assertThat(searchIds("Java", city, "FULL_TIME", 15000, 25000, companyA)).containsExactly(match);
+ }
+
+ @Test
+ void nonPublishedJobsAreAlwaysExcluded() {
+ String city = tag + "MYSQL_STATUS";
+ Long published = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ job(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000, JobStatus.DRAFT.name());
+ job(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000, JobStatus.CLOSED.name());
+
+ assertThat(searchIds(null, city, null, null, null, null)).containsExactly(published);
+ assertThat(searchIds(null, city, null, null, null, companyA)).containsExactly(published);
+ }
+
+ @Test
+ void latestOrderAndPaginationAreStable() {
+ String city = tag + "MYSQL_PAGE";
+ LocalDateTime base = LocalDateTime.of(2026, 3, 1, 0, 0);
+ List ids = new ArrayList<>();
+ for (int i = 0; i < 5; i++) {
+ Long id = published(companyA, "岗位" + i, "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ setCreatedAt(id, base.plusDays(i));
+ ids.add(id);
+ }
+ List expected = new ArrayList<>(ids);
+ java.util.Collections.reverse(expected);
+
+ var spec = JobSearchSpecification.searchJobs(null, city, null, null, null, null);
+ Pageable first = PageRequest.of(0, 2, latestSorted().getSort());
+ Pageable second = PageRequest.of(1, 2, latestSorted().getSort());
+
+ var p0 = jobRepository.findAll(spec, first);
+ var p1 = jobRepository.findAll(spec, second);
+
+ assertThat(p0.getContent().stream().map(Job::getId).toList())
+ .containsExactlyElementsOf(expected.subList(0, 2));
+ assertThat(p1.getContent().stream().map(Job::getId).toList())
+ .containsExactlyElementsOf(expected.subList(2, 4));
+ assertThat(p0.getTotalElements()).isEqualTo(5);
+ assertThat(p0.getTotalPages()).isEqualTo(3);
+ }
+
+ @Test
+ void salarySortNullLastIsConsistentWithH2() {
+ String city = tag + "MYSQL_NULLLAST";
+ Long high = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 30000);
+ Long mid = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ Long nullMax = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, null);
+
+ // 通过 Service 的 CASE WHEN 排序路径验证 NULL LAST
+ assertThat(idsViaSalarySort(city)).as("salaryMax DESC，NULL 最后")
+ .containsExactly(high, mid, nullMax);
+ }
+
+ /** 直接调用 Service 的 salary 排序路径（真实 EntityManager + CASE WHEN）。 */
+ private List idsViaSalarySort(String city) {
+ return jobService.searchJobs(null, city, null, null, null, null, "salary", 0, MAX_RESULTS)
+ .getContent().stream().map(com.mydreamjob.job.dto.JobSearchItem::getId).toList();
+ }
+
+ @Test
+ void companyIdFiltersExactly() {
+ String city = tag + "MYSQL_COMPANY";
+ Long mine = published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+ published(companyB, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ assertThat(searchIds(null, city, null, null, null, companyA)).containsExactly(mine);
+ }
+
+ @Test
+ void noResultReturnsEmptyPage() {
+ String city = tag + "MYSQL_EMPTY";
+ published(companyA, "岗位", "描述", "要求", city, "FULL_TIME", 10000, 20000);
+
+ var page = jobRepository.findAll(
+ JobSearchSpecification.searchJobs(tag + "不存在XYZ", city, null, null, null, null),
+ latestSorted());
+ assertThat(page.getContent()).isEmpty();
+ assertThat(page.getTotalElements()).isZero();
+ }
+}
diff --git a/mydreamjob-server/src/test/java/com/mydreamjob/job/Q01SqlRecorder.java b/mydreamjob-server/src/test/java/com/mydreamjob/job/Q01SqlRecorder.java
new file mode 100644
index 0000000..aa3a6a0
--- /dev/null
+++ b/mydreamjob-server/src/test/java/com/mydreamjob/job/Q01SqlRecorder.java
@@ -0,0 +1,34 @@
+package com.mydreamjob.job;
+
+import org.hibernate.resource.jdbc.spi.StatementInspector;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Q01 EXPLAIN 证据用：记录 Hibernate 实际执行过的 SQL。
+ *
+ * 通过 {@code hibernate.session_factory.statement_inspector} 注册（仅 MySQL EXPLAIN
+ * 用例使用），用来在报告中留下**真实生成**的 SQL 原文，而不是只留一份手写的等价 SQL。
+ */
+public class Q01SqlRecorder implements StatementInspector {
+
+ private static final List STATEMENTS = Collections.synchronizedList(new ArrayList<>());
+
+ @Override
+ public String inspect(String sql) {
+ STATEMENTS.add(sql);
+ return sql;
+ }
+
+ static void clear() {
+ STATEMENTS.clear();
+ }
+
+ static List drain() {
+ List copy = new ArrayList<>(STATEMENTS);
+ STATEMENTS.clear();
+ return copy;
+ }
+}
diff --git a/mydreamjob-server/src/test/resources/application-mysql-it.yml b/mydreamjob-server/src/test/resources/application-mysql-it.yml
new file mode 100644
index 0000000..d6d9cde
--- /dev/null
+++ b/mydreamjob-server/src/test/resources/application-mysql-it.yml
@@ -0,0 +1,55 @@
+# Q01 MySQL 真实层（Testcontainers）测试配置。
+#
+# 只提供应用级测试开关与测试专用 JWT 密钥；**不覆盖数据源与 JPA 方言**：
+# - 连接参数（URL / 用户名 / 密码）由测试类的 @DynamicPropertySource 注入容器地址；
+# - 方言与 ddl-auto 沿用主配置（org.hibernate.dialect.MySQLDialect + validate）。
+# 这样 MySQL 用例与 H2 用例跑在**同一套应用配置**上，仅有数据库实现不同，便于逐项对账。
+#
+# 密钥仅用于本地测试，长度 ≥ 32 且三项两两不同，满足 AppJwtProperties 校验。
+
+spring:
+ config:
+ activate:
+ on-profile: mysql-it
+ main:
+ allow-bean-definition-overriding: true
+ autoconfigure:
+ exclude:
+ - org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration
+ data:
+ redis:
+ enabled: false
+ rabbitmq:
+ enabled: false
+
+app:
+ redis:
+ enabled: false
+ notification:
+ mq-enabled: false
+ offer:
+ scheduler:
+ enabled: false
+ match:
+ notification:
+ enabled: false
+ risk:
+ scan:
+ enabled: false
+ resume:
+ storage-dir: ./target/resumes
+ export-dir: ./target/resume-exports
+ data-export:
+ dir: ./target/data-exports
+ file-ttl-hours: 24
+ jwt:
+ secret: mysql-it-legacy-secret-for-q01-tests-only-0001
+ access-secret: mysql-it-access-secret-for-q01-tests-only-0001
+ refresh-secret: mysql-it-refresh-secret-for-q01-tests-only-0001
+ token-hash-secret: mysql-it-token-hash-secret-for-q01-tests-only-0001
+ expiration-ms: 3600000
+ refresh-expiration-ms: 86400000
+ sms:
+ mock:
+ enabled: true
+ expire-seconds: 300