init

2026-03-19 00:23:45 +08:00 · 2025-05-14 10:16:48 +08:00
commit 3cd59337e7
220 changed files with 23768 additions and 0 deletions
--- a/backend/src/test/java/com/zl/mjga/integration/persistence/AbstractDataAccessLayerTest.java
+++ b/backend/src/test/java/com/zl/mjga/integration/persistence/AbstractDataAccessLayerTest.java
@@ -0,0 +1,33 @@
+package com.zl.mjga.integration.persistence;
+
+import org.springframework.boot.test.autoconfigure.jdbc.AutoConfigureTestDatabase;
+import org.springframework.boot.test.autoconfigure.jooq.JooqTest;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.ComponentScans;
+import org.springframework.test.context.DynamicPropertyRegistry;
+import org.springframework.test.context.DynamicPropertySource;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.junit.jupiter.Testcontainers;
+
+@JooqTest
+@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
+@ComponentScans({@ComponentScan("jooq.tables.daos"), @ComponentScan("com.zl.mjga.repository")})
+@Testcontainers
+public class AbstractDataAccessLayerTest {
+
+  public static PostgreSQLContainer<?> postgres =
+      new PostgreSQLContainer<>("postgres:17.3-alpine").withDatabaseName("mjga");
+
+  @DynamicPropertySource
+  static void postgresProperties(DynamicPropertyRegistry registry) {
+    registry.add("spring.datasource.url", postgres::getJdbcUrl);
+    registry.add("spring.datasource.username", postgres::getUsername);
+    registry.add("spring.datasource.password", postgres::getPassword);
+    registry.add("spring.flyway.locations", () -> "classpath:db/migration/test");
+    registry.add("spring.flyway.default-schema", () -> "public");
+  }
+
+  static {
+    postgres.start();
+  }
+}
--- a/backend/src/test/java/com/zl/mjga/integration/persistence/JooqTutorialsTest.java
+++ b/backend/src/test/java/com/zl/mjga/integration/persistence/JooqTutorialsTest.java
@@ -0,0 +1,160 @@
+package com.zl.mjga.integration.persistence;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.jooq.generated.mjga.tables.User.USER;
+import static org.jooq.impl.DSL.asterisk;
+
+import java.util.List;
+import org.jooq.DSLContext;
+import org.jooq.Record;
+import org.jooq.Result;
+import org.jooq.generated.mjga.tables.pojos.User;
+import org.jooq.generated.mjga.tables.records.UserRecord;
+import org.jooq.impl.DSL;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.jdbc.Sql;
+
+public class JooqTutorialsTest extends AbstractDataAccessLayerTest {
+
+  @Autowired private DSLContext dsl;
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (2, 'testUserB','lbHHwHjTzpOiRHTs')"
+      })
+  void queryWithDsl() {
+    List<User> users = dsl.selectFrom(USER).fetchInto(User.class);
+    assertThat(users.size()).isEqualTo(2);
+    assertThat(users.get(0).getUsername()).isEqualTo("testUserA");
+    assertThat(users.get(1).getUsername()).isEqualTo("testUserB");
+  }
+
+  @Test
+  void insertWithOrmFeel() {
+    UserRecord userRecord = dsl.newRecord(USER);
+    userRecord.setUsername("9hrb5Fv@gmail.com");
+    userRecord.setPassword("falr2b9nCVY5hS1o");
+    userRecord.store();
+    UserRecord fetchedOne = dsl.fetchOne(USER, USER.USERNAME.eq("9hrb5Fv@gmail.com"));
+    assertThat(fetchedOne.getPassword()).isEqualTo("falr2b9nCVY5hS1o");
+  }
+
+  @Test
+  void updateWithOrmFeel() {
+    UserRecord userRecord = dsl.newRecord(USER);
+    userRecord.setUsername("9hrb5Fv@gmail.com");
+    userRecord.setPassword("falr2b9nCVY5hS1o");
+    userRecord.store();
+
+    UserRecord fetchedOne = dsl.fetchOne(USER, USER.USERNAME.eq("9hrb5Fv@gmail.com"));
+    assertThat(fetchedOne.getPassword()).isEqualTo("falr2b9nCVY5hS1o");
+
+    userRecord.setPassword("JHMDoQPKuEcgILE6");
+    userRecord.store();
+
+    fetchedOne.refresh();
+    assertThat(fetchedOne.getPassword()).isEqualTo("JHMDoQPKuEcgILE6");
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (2, 'testUserB','lbHHwHjTzpOiRHTs')"
+      })
+  void deleteWithOrmFeel() {
+    UserRecord userRecord1 = dsl.fetchOne(USER, USER.USERNAME.eq("testUserA"));
+    assertThat(userRecord1.get(USER.USERNAME)).isEqualTo("testUserA");
+    userRecord1.delete();
+    UserRecord userRecord2 = dsl.fetchOne(USER, USER.USERNAME.eq("testUserA"));
+    assertThat(userRecord2).isNull();
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (2, 'testUserB','lbHHwHjTzpOiRHTs')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (3, 'testUserC','yF25WscLYmA8')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (4, 'testUserD','yF25WscLYmA8')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (5, 'testUserE','x60FelJjyd0B')"
+      })
+  void pagingQuery() {
+    List<User> users =
+        dsl.select(USER.USERNAME).from(USER).limit(2).offset(1).fetchInto(User.class);
+    assertThat(users.size()).isEqualTo(2);
+    assertThat(users.get(0).getUsername()).isEqualTo("testUserB");
+    assertThat(users.get(1).getUsername()).isEqualTo("testUserC");
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (2, 'testUserB','lbHHwHjTzpOiRHTs')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (3, 'testUserC','yF25WscLYmA8')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (4, 'testUserD','yF25WscLYmA8')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (5, 'testUserE','x60FelJjyd0B')"
+      })
+  void pagingSortQuery() {
+    List<User> users =
+        dsl.select(USER.USERNAME)
+            .from(USER)
+            .orderBy(USER.ID.desc())
+            .limit(3)
+            .offset(1)
+            .fetchInto(User.class);
+    assertThat(users.size()).isEqualTo(3);
+    assertThat(users.get(0).getUsername()).isEqualTo("testUserD");
+    assertThat(users.get(1).getUsername()).isEqualTo("testUserC");
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','a')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (2, 'testUserB','b')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (3, 'testUserC','c')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (4, 'testUserD','c')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (5, 'testUserE','c')"
+      })
+  void fetchAndTiesQuery() {
+    List<User> users =
+        dsl.select(USER.USERNAME)
+            .from(USER)
+            .orderBy(USER.PASSWORD.asc())
+            .limit(3)
+            .withTies()
+            .offset(0)
+            .fetchInto(User.class);
+    assertThat(users.size()).isEqualTo(5);
+    assertThat(users.get(0).getUsername()).isEqualTo("testUserA");
+    assertThat(users.get(4).getUsername()).isEqualTo("testUserE");
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','a')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (2, 'testUserB','b')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (3, 'testUserC','c')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (4, 'testUserD','e')",
+        "INSERT INTO mjga.user (id, username, password) VALUES (5, 'testUserE','f')"
+      })
+  void windowFunctionQuery() {
+    Result<Record> resultWithWindow =
+        dsl.select(asterisk(), DSL.count().over().as("total_user"))
+            .from(USER)
+            .orderBy(USER.ID.asc())
+            .limit(4)
+            .offset(0)
+            .fetch();
+    assertThat(resultWithWindow.size()).isEqualTo(4);
+    assertThat(resultWithWindow.get(0).getValue("total_user")).isEqualTo(5);
+    assertThat(resultWithWindow.get(0).getValue(USER.USERNAME)).isEqualTo("testUserA");
+    assertThat(resultWithWindow.get(1).getValue(USER.USERNAME)).isEqualTo("testUserB");
+  }
+}
--- a/backend/src/test/java/com/zl/mjga/integration/persistence/SortByDALTest.java
+++ b/backend/src/test/java/com/zl/mjga/integration/persistence/SortByDALTest.java
@@ -0,0 +1,71 @@
+package com.zl.mjga.integration.persistence;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.jooq.generated.mjga.tables.User.USER;
+
+import com.zl.mjga.dto.PageRequestDto;
+import com.zl.mjga.dto.urp.UserQueryDto;
+import com.zl.mjga.repository.*;
+import java.util.HashMap;
+import org.jooq.Record;
+import org.jooq.Result;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.jdbc.Sql;
+
+public class SortByDALTest extends AbstractDataAccessLayerTest {
+  @Autowired private UserRoleMapRepository userRoleMapRepository;
+
+  @Autowired private RolePermissionMapRepository rolePermissionMapRepository;
+
+  @Autowired private UserRepository userRepository;
+
+  @Autowired private RoleRepository roleRepository;
+
+  @Autowired private PermissionRepository permissionRepository;
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.user (id, username,password) VALUES (2, 'testB','NTjRCeUq2EqCy')",
+        "INSERT INTO mjga.user (id, username,password) VALUES (3, 'testC','qFVVFvPqs291k10')",
+      })
+  void userPageFetchWithNoSort() {
+    UserQueryDto rbacQueryDto = new UserQueryDto("test");
+    Result<Record> records = userRepository.pageFetchBy(PageRequestDto.of(1, 10), rbacQueryDto);
+    assertThat(records.get(0).get(USER.ID)).isEqualTo(1);
+    assertThat(records.get(1).get(USER.ID)).isEqualTo(2);
+    assertThat(records.get(2).get(USER.ID)).isEqualTo(3);
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testA','1')",
+        "INSERT INTO mjga.user (id, username,password) VALUES (2, 'testB','2')",
+        "INSERT INTO mjga.user (id, username,password) VALUES (3, 'testC','3')",
+        "INSERT INTO mjga.user (id, username,password) VALUES (4, 'testD','3')",
+      })
+  void userPageFetchWithSort() {
+    UserQueryDto rbacQueryDto = new UserQueryDto("test");
+    HashMap<String, PageRequestDto.Direction> sortByIdDesc = new HashMap<>();
+    sortByIdDesc.put("id", PageRequestDto.Direction.DESC);
+    Result<Record> records =
+        userRepository.pageFetchBy(PageRequestDto.of(1, 10, sortByIdDesc), rbacQueryDto);
+    assertThat(records.get(0).get(USER.ID)).isEqualTo(4);
+    assertThat(records.get(1).get(USER.ID)).isEqualTo(3);
+    assertThat(records.get(2).get(USER.ID)).isEqualTo(2);
+    assertThat(records.get(3).get(USER.ID)).isEqualTo(1);
+
+    HashMap<String, PageRequestDto.Direction> sortByPasswordAndId = new HashMap<>();
+    sortByPasswordAndId.put("password", PageRequestDto.Direction.DESC);
+    sortByIdDesc.put("id", PageRequestDto.Direction.ASC);
+    Result<Record> records2 =
+        userRepository.pageFetchBy(PageRequestDto.of(1, 10, sortByPasswordAndId), rbacQueryDto);
+    assertThat(records2.get(0).get(USER.ID)).isEqualTo(3);
+    assertThat(records2.get(1).get(USER.ID)).isEqualTo(4);
+    assertThat(records2.get(2).get(USER.ID)).isEqualTo(2);
+    assertThat(records2.get(3).get(USER.ID)).isEqualTo(1);
+  }
+}
--- a/backend/src/test/java/com/zl/mjga/integration/persistence/UserRolePermissionDALTest.java
+++ b/backend/src/test/java/com/zl/mjga/integration/persistence/UserRolePermissionDALTest.java
@@ -0,0 +1,219 @@
+package com.zl.mjga.integration.persistence;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.jooq.generated.mjga.tables.Permission.PERMISSION;
+import static org.jooq.generated.mjga.tables.Role.ROLE;
+import static org.jooq.generated.mjga.tables.User.USER;
+
+import com.zl.mjga.dto.PageRequestDto;
+import com.zl.mjga.dto.urp.PermissionQueryDto;
+import com.zl.mjga.dto.urp.RoleQueryDto;
+import com.zl.mjga.dto.urp.UserQueryDto;
+import com.zl.mjga.model.urp.BindState;
+import com.zl.mjga.repository.*;
+import java.util.List;
+import java.util.stream.Collectors;
+import org.jooq.Record;
+import org.jooq.Result;
+import org.jooq.generated.mjga.tables.pojos.Permission;
+import org.jooq.generated.mjga.tables.pojos.Role;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.test.context.jdbc.Sql;
+
+public class UserRolePermissionDALTest extends AbstractDataAccessLayerTest {
+
+  @Autowired private UserRoleMapRepository userRoleMapRepository;
+
+  @Autowired private RolePermissionMapRepository rolePermissionMapRepository;
+
+  @Autowired private UserRepository userRepository;
+
+  @Autowired private RoleRepository roleRepository;
+
+  @Autowired private PermissionRepository permissionRepository;
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (1, 'testRoleA', 'testRoleA')",
+        "INSERT INTO mjga.user_role_map (user_id, role_id) VALUES (1, 1)"
+      })
+  void userRoleMap_deleteByUserId() {
+    userRoleMapRepository.deleteByUserId(1L);
+    assertThat(userRoleMapRepository.fetchByUserId(1L).isEmpty()).isTrue();
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (1, 'testRoleA', 'testRoleA')",
+        "INSERT INTO mjga.permission (id, code, name) VALUES (1, 'testPermissionA',"
+            + " 'testPermissionA')",
+        "INSERT INTO mjga.role_permission_map (role_id, permission_id) VALUES (1, 1)",
+      })
+  void rolePermissionMap_deleteByRoleId() {
+    rolePermissionMapRepository.deleteByRoleId(1L);
+    assertThat(rolePermissionMapRepository.fetchByRoleId(1L).isEmpty()).isTrue();
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testUserA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.user (id, username,password) VALUES (2, 'testUserB','NTjRCeUq2EqCy')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (1, 'testRoleA', 'testRoleA')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (2, 'testRoleB', 'testRoleB')",
+        "INSERT INTO mjga.permission (id, code, name) VALUES (1, 'testPermissionA',"
+            + " 'testPermissionA')",
+        "INSERT INTO mjga.permission (id, code, name) VALUES (2, 'testPermissionB',"
+            + " 'testPermissionB')",
+        "INSERT INTO mjga.user_role_map (user_id, role_id) VALUES (1, 1)",
+        "INSERT INTO mjga.role_permission_map (role_id, permission_id) VALUES (1, 1)",
+        "INSERT INTO mjga.role_permission_map (role_id, permission_id) VALUES (1, 2)",
+        "INSERT INTO mjga.user_role_map (user_id, role_id) VALUES (2, 2)",
+        "INSERT INTO mjga.role_permission_map (role_id, permission_id) VALUES (2, 2)",
+      })
+  void user_fetchUniqueUserWithRolePermissionBy() {
+    Result<Record> records = userRepository.fetchUniqueUserWithRolePermissionBy(1L);
+    assertThat(records.size()).isEqualTo(2);
+    assertThat(records.get(0).get(USER.USERNAME)).isEqualTo("testUserA");
+    assertThat(records.get(1).get(USER.USERNAME)).isEqualTo("testUserA");
+    assertThat(records.get(0).get(ROLE.NAME)).isEqualTo("testRoleA");
+    assertThat(records.get(1).get(ROLE.NAME)).isEqualTo("testRoleA");
+
+    List<String> names =
+        records.stream().map(record -> record.get(PERMISSION.NAME)).collect(Collectors.toList());
+    assertThat(names).containsExactlyInAnyOrder("testPermissionA", "testPermissionB");
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.user (id, username, password) VALUES (1, 'testA','5EUX1AIlV09n2o')",
+        "INSERT INTO mjga.user (id, username,password) VALUES (2, 'testB','NTjRCeUq2EqCy')",
+      })
+  void user_pageFetchBy() {
+    UserQueryDto rbacQueryDto = new UserQueryDto("test");
+    Result<Record> records = userRepository.pageFetchBy(PageRequestDto.of(1, 10), rbacQueryDto);
+    assertThat(records.size()).isEqualTo(2);
+
+    assertThat(records.get(0).get(USER.ID)).isEqualTo(1);
+    assertThat(records.get(1).get(USER.ID)).isEqualTo(2);
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.role (id, code, name) VALUES (1, 'testRoleA', 'testRoleA')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (2, 'testRoleB', 'testRoleB')",
+      })
+  void role_selectByRoleIdIn() {
+    List<Role> roles = roleRepository.selectByRoleIdIn(List.of(1L, 2L));
+    assertThat(roles.size()).isEqualTo(2);
+    assertThat(roles.get(0).getId()).isEqualTo(1L);
+    assertThat(roles.get(1).getId()).isEqualTo(2L);
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.role (id, code, name) VALUES (1, 'testRoleA', 'testRoleA')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (2, 'testRoleB', 'testRoleB')",
+      })
+  void role_selectByRoleCodeIn() {
+    List<Role> roles = roleRepository.selectByRoleCodeIn(List.of("testRoleA", "testRoleB"));
+    assertThat(roles.size()).isEqualTo(2);
+    assertThat(roles.get(0).getId()).isEqualTo(1L);
+    assertThat(roles.get(1).getId()).isEqualTo(2L);
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.role (id, code, name) VALUES (1, 'testRoleA', 'testRoleA')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (2, 'testRoleB', 'testRoleB')",
+      })
+  void role_pageFetchBy() {
+    RoleQueryDto roleQueryDto = new RoleQueryDto();
+    roleQueryDto.setRoleName("testRole");
+    roleQueryDto.setBindState(BindState.ALL);
+    Result<Record> records = roleRepository.pageFetchBy(PageRequestDto.of(1, 10), roleQueryDto);
+    assertThat(records.get(0).getValue("total_role")).isEqualTo(2);
+    assertThat(records.get(0).getValue(ROLE.NAME)).isEqualTo("testRoleA");
+    assertThat(records.get(1).getValue(ROLE.NAME)).isEqualTo("testRoleB");
+
+    roleQueryDto = new RoleQueryDto();
+    roleQueryDto.setRoleCode("testRoleA");
+    roleQueryDto.setBindState(BindState.ALL);
+    records = roleRepository.pageFetchBy(PageRequestDto.of(1, 10), roleQueryDto);
+    assertThat(records.get(0).getValue("total_role")).isEqualTo(1);
+    assertThat(records.get(0).getValue(ROLE.NAME)).isEqualTo("testRoleA");
+
+    roleQueryDto = new RoleQueryDto();
+    roleQueryDto.setRoleName("test");
+    roleQueryDto.setRoleCode("testRoleA");
+    roleQueryDto.setBindState(BindState.ALL);
+    records = roleRepository.pageFetchBy(PageRequestDto.of(1, 10), roleQueryDto);
+    assertThat(records.get(0).getValue("total_role")).isEqualTo(1);
+    assertThat(records.get(0).getValue(ROLE.NAME)).isEqualTo("testRoleA");
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.role (id, code, name) VALUES (1, 'testRoleA', 'testRoleA')",
+        "INSERT INTO mjga.role (id, code, name) VALUES (2, 'testRoleB', 'testRoleB')",
+        "INSERT INTO mjga.permission (id, code, name) VALUES (1, 'testPermissionA',"
+            + " 'testPermissionA')",
+        "INSERT INTO mjga.permission (id, code, name) VALUES (2, 'testPermissionB',"
+            + " 'testPermissionB')",
+        "INSERT INTO mjga.role_permission_map (role_id, permission_id) VALUES (1, 1)",
+        "INSERT INTO mjga.role_permission_map (role_id, permission_id) VALUES (1, 2)",
+        "INSERT INTO mjga.role_permission_map (role_id, permission_id) VALUES (2, 2)",
+      })
+  void role_fetchUniqueRoleWithPermission() {
+    Result<Record> records = roleRepository.fetchUniqueRoleWithPermission(1L);
+    assertThat(records.size()).isEqualTo(2L);
+    assertThat(records.get(0).getValue(ROLE.NAME)).isEqualTo("testRoleA");
+    assertThat(records.get(1).getValue(ROLE.NAME)).isEqualTo("testRoleA");
+    assertThat(records.get(0).getValue(PERMISSION.NAME)).isEqualTo("testPermissionA");
+    assertThat(records.get(1).getValue(PERMISSION.NAME)).isEqualTo("testPermissionB");
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.permission (id, code, name) VALUES (1, 'testPermissionA',"
+            + " 'testPermissionA')",
+        "INSERT INTO mjga.permission (id, code, name) VALUES (2, 'testPermissionB',"
+            + " 'testPermissionB')",
+      })
+  void permission_selectByPermissionIdIn() {
+    List<Permission> permissions = permissionRepository.selectByPermissionIdIn(List.of(1L));
+    assertThat(permissions.size()).isEqualTo(1);
+    assertThat(permissions.get(0).getId()).isEqualTo(1L);
+  }
+
+  @Test
+  @Sql(
+      statements = {
+        "INSERT INTO mjga.permission (id, code, name) VALUES (1, 'testPermissionA',"
+            + " 'testPermissionA')",
+        "INSERT INTO mjga.permission (id, code, name) VALUES (2, 'testPermissionB',"
+            + " 'testPermissionB')",
+      })
+  void permission_pageFetchBy() {
+    PermissionQueryDto permissionQueryDto = new PermissionQueryDto();
+    permissionQueryDto.setPermissionCode("testPermissionA");
+    permissionQueryDto.setPermissionName("test");
+    permissionQueryDto.setPermissionIdList(List.of(1L));
+
+    Result<Record> records =
+        permissionRepository.pageFetchBy(PageRequestDto.of(1, 10), permissionQueryDto);
+    assertThat(records.get(0).getValue("total_permission")).isEqualTo(1);
+    assertThat(records.get(0).getValue(PERMISSION.NAME)).isEqualTo("testPermissionA");
+  }
+}