[FEAT] 채팅 서비스 개발

[Be-HinD]

✨ 요청 기능 설명

설계된 아키텍처를 기반으로 서비스 내 채팅 기능 개발

🔍 해결해야 하는 문제

설계에 맞는 백엔드 로직 구현 및 테스트 진행

🧩 구현 아이디어

설계 문서 작성 시점 업데이트

📌 작업 범위 (선택)

• API 개발
• 문서 작성

📝 비고

기타 관련 정보가 있으면 작성해주세요.

[coderabbitai]

📝 CodeRabbit Plan Mode

Generate an implementation plan and prompts that you can use with your favorite coding agent.

✅ Successfully generated implementation plan.

💡 Use @coderabbitai <feedback> to replan

Examples

• Example 1
• Example 2

---

🔗 Similar Issues

Related Issues

• [FEAT] 채팅 서비스 설계 #166
• [FEAT] 모임 V2 테스트 개선과 HTTP Method 수정 #156
• [FEAT] 모임 상세 조회와 커서 기반 검색 구현 #67
• [FEAT] V2 모임 Swagger 작성 #143

👤 Suggested Assignees

• LimdaeIl
• Be-HinD

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord or schedule a call!

[coderabbitai]

Coding Plan

Approach

Complete the chat service implementation by addressing architectural gaps in entity auditing and soft delete mechanisms, establishing comprehensive test coverage, and updating documentation to reflect the current implementation state.

Observations

The WeGo project is a Spring Boot 3.5.8 application with a well-structured chat module that is largely implemented. The chat package follows a layered architecture with presentation (controllers), application (services/DTOs), domain (entities/repositories), and configuration layers.

The module includes:

• WebSocket/STOMP support for real-time messaging
• Event-driven integration with the group service for automatic chat room creation
• 7-8 REST API endpoints with proper Swagger documentation

However, the entity layer has inconsistent auditing patterns and lacks soft delete mechanisms required by the architecture specification. Current test infrastructure has only 3 integration tests and no unit tests, repository tests, or WebSocket tests.

Assumptions

Assumption 1: Should entities use Spring Data JPA auditing or manual timestamp management?

Options Considered:

• Add Spring Data JPA @CreatedDate/@LastModifiedDate with AuditingEntityListener (standard Spring pattern)
• Keep manual LocalDateTime.now() assignments in entity constructors (current approach)

Chosen Option: 1

Rationale: This aligns with Spring Boot best practices, provides automatic timestamp management, and ensures consistency across all entities as specified in the architecture documentation.

Assumption 2: Should the chat service implement soft delete or hard delete?

Options Considered:

• Implement soft delete with @SQLDelete, @where, and deleted_at timestamp field
• Continue using hard delete (current state)

Chosen Option: 1

Rationale: Soft delete is implied in the architecture best practices and provides better audit capabilities, allows data recovery, and maintains referential integrity for historical chat data.

Assumption 3: What test coverage strategy should be implemented?

Options Considered:

• Comprehensive testing with unit tests (mocked), integration tests (@SpringBootTest), repository tests (@DataJpaTest), and WebSocket tests
• Integration tests only (current minimal approach)

Chosen Option: 1

Rationale: The ticket explicitly mentions "테스트 진행" (conduct testing) and best practices require multiple test layers for maintainability and confidence in the implementation.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: Entity Auditing and Soft Delete Implementation

Align entity implementations with architectural specifications by adding Spring Data JPA auditing support and soft delete mechanisms across all chat entities.

Task 1: Configure JPA Auditing Infrastructure

Enable Spring Data JPA auditing for automatic timestamp management

• Add @EnableJpaAuditing annotation to the main application class WegobackendApplication.java or create a dedicated JPA configuration class
• This enables automatic management of @CreatedDate and @LastModifiedDate annotated fields

Task 2: Update ChatRoom Entity with Auditing Fields

Add missing timestamp fields to ChatRoom entity to match architecture specification

• Update src/main/java/team/wego/wegobackend/chat/domain/entity/ChatRoom.java to add:
  • @EntityListeners(AuditingEntityListener.class) at class level
  • created_at field with @CreatedDate annotation
  • updated_at field with @LastModifiedDate annotation
• Both fields should be LocalDateTime type with @Column(nullable = false, updatable = false) for created_at

Task 3: Refactor ChatMessage and ChatParticipant Auditing

Replace manual timestamp assignments with Spring Data JPA auditing annotations

• Update src/main/java/team/wego/wegobackend/chat/domain/entity/ChatMessage.java:
  • Add @EntityListeners(AuditingEntityListener.class) at class level
  • Replace manual created_at = LocalDateTime.now() with @CreatedDate annotation
• Update src/main/java/team/wego/wegobackend/chat/domain/entity/ChatParticipant.java:
  • Add @EntityListeners(AuditingEntityListener.class) at class level
  • Add @LastModifiedDate annotation to existing updated_at field
  • Remove any manual timestamp setting code

Task 4: Implement Soft Delete Mechanism

Add soft delete support to all chat entities for audit trail preservation

• Update all three entities (ChatRoom.java, ChatMessage.java, ChatParticipant.java) in src/main/java/team/wego/wegobackend/chat/domain/entity/ to add:
  • deleted_at field of type LocalDateTime with @Column(name = "deleted_at")
  • @SQLDelete(sql = "UPDATE {table_name} SET deleted_at = NOW() WHERE id = ?") annotation at class level
  • @Where(clause = "deleted_at IS NULL") annotation at class level
• Update corresponding repositories in src/main/java/team/wego/wegobackend/chat/domain/repository/ if custom delete queries need modification

🤖 Prompt for AI agents

Implement Spring Data JPA auditing and soft delete mechanisms for chat entities.
Enable automatic timestamp management and data preservation for audit trails.

Enable JPA auditing by adding @EnableJpaAuditing to the main application class
or creating a dedicated configuration class.

Update ChatRoom entity to add @EntityListeners(AuditingEntityListener.class),
created_at field with @CreatedDate, and updated_at field with @LastModifiedDate.

Update ChatMessage entity to add @EntityListeners(AuditingEntityListener.class)
and replace manual LocalDateTime.now() assignments with @CreatedDate annotation.

Update ChatParticipant entity to add
@EntityListeners(AuditingEntityListener.class), add @LastModifiedDate to
updated_at field, and remove manual timestamp code.

Implement soft delete for all three entities (ChatRoom, ChatMessage,
ChatParticipant) by adding deleted_at field (LocalDateTime), @SQLDelete
annotation with UPDATE SQL setting deleted_at to NOW(), and @Where clause
filtering deleted_at IS NULL.

Review and update repository custom queries if needed to respect soft delete
behavior.

Phase 2: Comprehensive Test Suite Development

Establish a complete test infrastructure covering unit tests, integration tests, repository tests, and WebSocket messaging scenarios.

Task 1: Create Test Fixtures and Builders

Build reusable test data creation utilities for chat entities

• Create test fixture classes in src/test/java/team/wego/wegobackend/chat/fixtures/:
  • ChatRoomFixture.java - builder pattern for creating test chat rooms
  • ChatMessageFixture.java - builder for test messages
  • ChatParticipantFixture.java - builder for test participants
  • UserFixture.java (if not exists) - builder for test users
• Each fixture should provide methods for common test scenarios (e.g., createGroupChatRoom(), createDmChatRoom(), createActiveParticipant())
• Follow the pattern seen in existing test files (GroupCursorDummyTest.java, MyGroupsDummyTest.java)

Task 2: Implement Service Layer Unit Tests

Add unit tests for chat services using Mockito for dependency mocking

• Create ChatRoomServiceTest.java in src/test/java/team/wego/wegobackend/chat/application/service/:
  • Use @ExtendWith(MockitoExtension.class), @Mock for repositories, @InjectMocks for service
  • Test business logic: room creation, participant management, leave room scenarios
  • Test exception handling for invalid operations
• Create ChatMessageServiceTest.java:
  • Test message sending validation, content length checks
  • Test message persistence logic
  • Mock WebSocket message sending operations

Task 3: Implement Repository Tests with @DataJpaTest

Add isolated repository tests for custom query methods and relationship handling

• Create repository test classes in src/test/java/team/wego/wegobackend/chat/domain/repository/:
  • ChatRoomRepositoryTest.java - test room queries, participant counting
  • ChatMessageRepositoryTest.java - test cursor-based pagination queries, message retrieval
  • ChatParticipantRepositoryTest.java - test participant status queries, last read message updates
• Use @DataJpaTest annotation with H2 in-memory database
• Focus on testing custom @Query methods and relationship mappings (lazy loading, cascade operations)

Task 4: Create Integration Tests for REST APIs

Build end-to-end tests for all chat REST endpoints

• Create ChatRoomControllerIntegrationTest.java in src/test/java/team/wego/wegobackend/chat/presentation/:
  • Use @SpringBootTest with @AutoConfigureMockMvc
  • Test all 8 REST endpoints identified in exploration
  • Include authentication context using test user setup
  • Verify response structure matches ApiResponse<T> wrapper pattern
• Test positive scenarios and error cases (unauthorized access, invalid room IDs, validation failures)

Task 5: Implement WebSocket Messaging Tests

Add tests for real-time messaging functionality via WebSocket/STOMP

• Create ChatMessageControllerWebSocketTest.java in src/test/java/team/wego/wegobackend/chat/presentation/:
  • Use Spring's TestStompClient or MockMvc WebSocket support
  • Test message publishing to /pub/chat/message endpoint
  • Verify message broadcasting to subscribers at /sub/chat/room/{roomId}
  • Test WebSocket authentication and connection lifecycle
• Follow patterns from WebSocketConfig.java for endpoint configuration in tests

Task 6: Add Event Listener Tests

Test event-driven chat room creation triggered by group events

• Create ChatEventListenerTest.java in src/test/java/team/wego/wegobackend/chat/application/:
  • Test handleGroupCreated() event listener response
  • Test handleGroupJoined() and handleGroupLeft() listeners
  • Verify automatic chat room creation when GroupCreatedEvent is published
  • Use @SpringBootTest or mock ApplicationEventPublisher with Mockito
  • Ensure @Async behavior doesn't affect test reliability

🤖 Prompt for AI agents

Build a comprehensive test suite covering all layers of the chat service. Create
test fixtures, unit tests, repository tests, integration tests, WebSocket tests,
and event listener tests.

Create test fixtures in chat/fixtures/ package:
- ChatRoomFixture with builder methods for group and DM chat rooms
- ChatMessageFixture with builder for test messages
- ChatParticipantFixture with builder for participants
- UserFixture if not already exists

Implement service layer unit tests:
- ChatRoomServiceTest using @ExtendWith(MockitoExtension), @Mock, and
@InjectMocks
- Test room creation, participant management, leave scenarios, and exception
handling
- ChatMessageServiceTest for message validation, persistence, and mocked
WebSocket operations

Create repository tests with @DataJpaTest:
- ChatRoomRepositoryTest for room queries and participant counting
- ChatMessageRepositoryTest for cursor pagination and message retrieval
- ChatParticipantRepositoryTest for status queries and last read updates
- Focus on custom @Query methods and relationship mappings

Build REST API integration tests:
- ChatRoomControllerIntegrationTest using @SpringBootTest and
@AutoConfigureMockMvc
- Test all 8 REST endpoints with authentication context
- Verify ApiResponse wrapper structure and error cases

Implement WebSocket messaging tests:
- ChatMessageControllerWebSocketTest using TestStompClient
- Test message publishing to /pub/chat/message
- Verify broadcasting to /sub/chat/room/{roomId}
- Test authentication and connection lifecycle

Create event listener tests:
- ChatEventListenerTest for group event handling
- Test handleGroupCreated, handleGroupJoined, handleGroupLeft listeners
- Verify automatic chat room creation and @Async behavior

Phase 3: Documentation and Code Cleanup

Update project documentation to reflect the completed implementation and any architectural decisions made.

Task 1: Update Architecture Documentation

Document implemented auditing and soft delete patterns

• Update docs/채팅서비스_아키텍처.md:
  • Add section on JPA auditing implementation with @CreatedDate/@LastModifiedDate
  • Document soft delete mechanism with @SQLDelete and @Where annotations
  • Note that deleted_at field is used instead of isDeleted boolean
  • Update entity relationship diagrams if they exist to show auditing fields

Task 2: Document Testing Strategy

Create or update testing documentation describing test coverage and patterns

• Create docs/채팅서비스_테스트_가이드.md or update existing test documentation:
  • Document test fixture usage and builder patterns
  • Describe unit test approach with Mockito
  • Explain integration test setup with @SpringBootTest
  • Provide WebSocket testing examples
  • Include instructions for running tests and checking coverage

Task 3: Review and Update Code Documentation

Ensure inline documentation reflects implemented patterns

• Review entity classes in src/main/java/team/wego/wegobackend/chat/domain/entity/ for proper JavaDoc comments
• Add JavaDoc to service methods in ChatRoomService.java and ChatMessageService.java if missing
• Ensure controller methods have descriptions that align with Swagger annotations in ChatRoomControllerDocs.java
• Update any README or setup instructions to mention JPA auditing configuration requirement

🤖 Prompt for AI agents

Update project documentation to reflect the completed chat service
implementation including auditing, soft delete, and testing infrastructure.

Update architecture documentation (docs/채팅서비스_아키텍처.md):
- Add section explaining JPA auditing with @CreatedDate and @LastModifiedDate
- Document soft delete implementation using @SQLDelete and @Where annotations
- Note the use of deleted_at timestamp field instead of boolean flag
- Update entity relationship diagrams to include auditing fields

Create or update testing guide (docs/채팅서비스_테스트_가이드.md):
- Document test fixture patterns and builder usage
- Describe unit testing approach with Mockito
- Explain integration test setup with @SpringBootTest
- Provide WebSocket testing examples
- Include test execution and coverage checking instructions

Review and enhance code documentation:
- Add JavaDoc comments to entity classes in chat/domain/entity/
- Add JavaDoc to service methods in ChatRoomService and ChatMessageService
- Ensure controller documentation aligns with Swagger annotations in
ChatRoomControllerDocs
- Update README or setup instructions to mention JPA auditing configuration
requirement

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement Spring Data JPA auditing and soft delete mechanisms for chat entities.
Enable automatic timestamp management and data preservation for audit trails.

Enable JPA auditing by adding @EnableJpaAuditing to the main application class
or creating a dedicated configuration class.

Update ChatRoom entity to add @EntityListeners(AuditingEntityListener.class),
created_at field with @CreatedDate, and updated_at field with @LastModifiedDate.

Update ChatMessage entity to add @EntityListeners(AuditingEntityListener.class)
and replace manual LocalDateTime.now() assignments with @CreatedDate annotation.

Update ChatParticipant entity to add
@EntityListeners(AuditingEntityListener.class), add @LastModifiedDate to
updated_at field, and remove manual timestamp code.

Implement soft delete for all three entities (ChatRoom, ChatMessage,
ChatParticipant) by adding deleted_at field (LocalDateTime), @SQLDelete
annotation with UPDATE SQL setting deleted_at to NOW(), and @Where clause
filtering deleted_at IS NULL.

Review and update repository custom queries if needed to respect soft delete
behavior.
===============================================================================

Task: 2

Build a comprehensive test suite covering all layers of the chat service. Create
test fixtures, unit tests, repository tests, integration tests, WebSocket tests,
and event listener tests.

Create test fixtures in chat/fixtures/ package:
- ChatRoomFixture with builder methods for group and DM chat rooms
- ChatMessageFixture with builder for test messages
- ChatParticipantFixture with builder for participants
- UserFixture if not already exists

Implement service layer unit tests:
- ChatRoomServiceTest using @ExtendWith(MockitoExtension), @Mock, and
@InjectMocks
- Test room creation, participant management, leave scenarios, and exception
handling
- ChatMessageServiceTest for message validation, persistence, and mocked
WebSocket operations

Create repository tests with @DataJpaTest:
- ChatRoomRepositoryTest for room queries and participant counting
- ChatMessageRepositoryTest for cursor pagination and message retrieval
- ChatParticipantRepositoryTest for status queries and last read updates
- Focus on custom @Query methods and relationship mappings

Build REST API integration tests:
- ChatRoomControllerIntegrationTest using @SpringBootTest and
@AutoConfigureMockMvc
- Test all 8 REST endpoints with authentication context
- Verify ApiResponse wrapper structure and error cases

Implement WebSocket messaging tests:
- ChatMessageControllerWebSocketTest using TestStompClient
- Test message publishing to /pub/chat/message
- Verify broadcasting to /sub/chat/room/{roomId}
- Test authentication and connection lifecycle

Create event listener tests:
- ChatEventListenerTest for group event handling
- Test handleGroupCreated, handleGroupJoined, handleGroupLeft listeners
- Verify automatic chat room creation and @Async behavior
===============================================================================

Task: 3

Update project documentation to reflect the completed chat service
implementation including auditing, soft delete, and testing infrastructure.

Update architecture documentation (docs/채팅서비스_아키텍처.md):
- Add section explaining JPA auditing with @CreatedDate and @LastModifiedDate
- Document soft delete implementation using @SQLDelete and @Where annotations
- Note the use of deleted_at timestamp field instead of boolean flag
- Update entity relationship diagrams to include auditing fields

Create or update testing guide (docs/채팅서비스_테스트_가이드.md):
- Document test fixture patterns and builder usage
- Describe unit testing approach with Mockito
- Explain integration test setup with @SpringBootTest
- Provide WebSocket testing examples
- Include test execution and coverage checking instructions

Review and enhance code documentation:
- Add JavaDoc comments to entity classes in chat/domain/entity/
- Add JavaDoc to service methods in ChatRoomService and ChatMessageService
- Ensure controller documentation aligns with Swagger annotations in
ChatRoomControllerDocs
- Update README or setup instructions to mention JPA auditing configuration
requirement

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- @coderabbitai You can skip phase 3. Add a simple unit test case for phase 2.
- @coderabbitai For assumption 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!