diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/Capsule.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/Capsule.java
index feab13c7b..833fc102e 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/Capsule.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/Capsule.java
@@ -14,16 +14,20 @@
 import jakarta.persistence.ManyToOne;
 import jakarta.persistence.OneToMany;
 import jakarta.persistence.Table;
+import java.time.ZoneId;
 import java.time.ZonedDateTime;
+import java.util.ArrayList;
 import java.util.List;
 import lombok.AccessLevel;
 import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import org.locationtech.jts.geom.Point;
+import site.timecapsulearchive.core.domain.capsule.exception.GroupCapsuleOpenNotFoundException;
 import site.timecapsulearchive.core.domain.capsuleskin.entity.CapsuleSkin;
 import site.timecapsulearchive.core.domain.group.entity.Group;
 import site.timecapsulearchive.core.domain.member.entity.Member;
+import site.timecapsulearchive.core.global.common.supplier.ZonedDateTimeSupplier;
 import site.timecapsulearchive.core.global.entity.BaseEntity;
 
 @Entity
@@ -60,13 +64,13 @@ public class Capsule extends BaseEntity {
     private Address address;
 
     @OneToMany(mappedBy = "capsule", cascade = CascadeType.ALL, orphanRemoval = true)
-    private List<Image> images;
+    private List<Image> images = new ArrayList<>();
 
     @OneToMany(mappedBy = "capsule", cascade = CascadeType.ALL, orphanRemoval = true)
-    private List<Video> videos;
+    private List<Video> videos = new ArrayList<>();
 
     @OneToMany(mappedBy = "capsule", cascade = CascadeType.ALL, orphanRemoval = true)
-    private List<GroupCapsuleOpen> groupCapsuleOpens;
+    private List<GroupCapsuleOpen> groupCapsuleOpens = new ArrayList<>();
 
     @ManyToOne(fetch = FetchType.LAZY)
     @JoinColumn(name = "group_id")
@@ -109,6 +113,33 @@ public boolean isNotCapsuleOpened() {
             return false;
         }
 
-        return dueDate.isAfter(ZonedDateTime.now());
+        return dueDate.isAfter(ZonedDateTimeSupplier.utc().get());
+    }
+
+    public void open() {
+        this.isOpened = Boolean.TRUE;
+    }
+
+    public boolean isTimeCapsule() {
+        return dueDate != null;
+    }
+
+    public boolean canOpen() {
+        return dueDate == null || dueDate.isBefore(ZonedDateTimeSupplier.utc().get());
+    }
+
+    public boolean isAllGroupMemberOpened(Long memberId, Long capsuleId) {
+        if (groupCapsuleOpens.isEmpty()) {
+            throw new GroupCapsuleOpenNotFoundException();
+        }
+
+        return groupCapsuleOpens.stream()
+            .allMatch(groupCapsuleOpen -> {
+                if (groupCapsuleOpen.matched(capsuleId, memberId)) {
+                    groupCapsuleOpen.open();
+                }
+
+                return groupCapsuleOpen.getIsOpened();
+            });
     }
 }
\ No newline at end of file
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/GroupCapsuleOpen.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/GroupCapsuleOpen.java
index d1e94f550..809d9dc64 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/GroupCapsuleOpen.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/entity/GroupCapsuleOpen.java
@@ -53,4 +53,8 @@ public static GroupCapsuleOpen createOf(Member member, Capsule capsule, Boolean
     public void open() {
         this.isOpened = Boolean.TRUE;
     }
+
+    public boolean matched(Long capsuleId, Long memberId) {
+        return capsule.getId().equals(capsuleId) && member.getId().equals(memberId);
+    }
 }
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/generic_capsule/repository/CapsuleRepository.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/generic_capsule/repository/CapsuleRepository.java
index 03908bba4..788197a56 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/generic_capsule/repository/CapsuleRepository.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/generic_capsule/repository/CapsuleRepository.java
@@ -23,4 +23,14 @@ int updateIsOpenedTrue(
         @Param("memberId") Long memberId,
         @Param("capsuleId") Long capsuleId
     );
+
+    @Query("select c "
+        + "from Capsule c "
+        + "join fetch c.groupCapsuleOpens "
+        + "where c.id = :capsuleId and c.member.id = :memberId "
+        + "and c.type = 'GROUP' and c.group.id is not null and c.isOpened = false")
+    Optional<Capsule> findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(
+        @Param("memberId") Long memberId,
+        @Param("capsuleId") Long capsuleId
+    );
 }
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApi.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApi.java
index 7a5371a4f..06fb9b364 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApi.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApi.java
@@ -22,6 +22,7 @@
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.reqeust.GroupCapsuleCreateRequest;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.reqeust.GroupCapsuleUpdateRequest;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsuleDetailResponse;
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsuleOpenStateResponse;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsulePageResponse;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsuleSummaryResponse;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.MyGroupCapsuleSliceResponse;
@@ -172,7 +173,7 @@ ResponseEntity<ApiSpec<MyGroupCapsuleSliceResponse>> getMyGroupCapsules(
             content = @Content(schema = @Schema(implementation = ErrorResponse.class))
         )
     })
-    ResponseEntity<ApiSpec<String>> openCapsule(
+    ResponseEntity<ApiSpec<GroupCapsuleOpenStateResponse>> openCapsule(
         Long memberId,
 
         @Parameter(in = ParameterIn.PATH, description = "개봉할 그룹 캡슐 아이디", required = true)
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApiController.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApiController.java
index 9b6089e3a..63f19c19a 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApiController.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/api/GroupCapsuleApiController.java
@@ -14,11 +14,13 @@
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleDetailDto;
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleOpenStateDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleSummaryDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.MyGroupCapsuleDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.reqeust.GroupCapsuleCreateRequest;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.reqeust.GroupCapsuleUpdateRequest;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsuleDetailResponse;
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsuleOpenStateResponse;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsulePageResponse;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsuleSummaryResponse;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.MyGroupCapsuleSliceResponse;
@@ -139,13 +141,19 @@ public ResponseEntity<ApiSpec<MyGroupCapsuleSliceResponse>> getMyGroupCapsules(
 
     @PostMapping("/{capsule_id}/open")
     @Override
-    public ResponseEntity<ApiSpec<String>> openCapsule(
+    public ResponseEntity<ApiSpec<GroupCapsuleOpenStateResponse>> openCapsule(
         @AuthenticationPrincipal final Long memberId,
         @PathVariable(value = "capsule_id") final Long capsuleId
     ) {
-        groupCapsuleService.openGroupCapsule(memberId, capsuleId);
+        GroupCapsuleOpenStateDto groupCapsuleOpenStateDto = groupCapsuleService.openGroupCapsule(
+            memberId, capsuleId);
 
-        return ResponseEntity.ok(ApiSpec.empty(SuccessCode.SUCCESS));
+        return ResponseEntity.ok(
+            ApiSpec.success(
+                SuccessCode.SUCCESS,
+                groupCapsuleOpenStateDto.toResponse()
+            )
+        );
     }
 
     @Override
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/dto/CapsuleOpenStatus.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/dto/CapsuleOpenStatus.java
new file mode 100644
index 000000000..750a8fb14
--- /dev/null
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/dto/CapsuleOpenStatus.java
@@ -0,0 +1,14 @@
+package site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto;
+
+import lombok.Getter;
+
+@Getter
+public enum CapsuleOpenStatus {
+    OPEN("캡슐이 개봉되었습니다."), NOT_OPEN("캡슐이 개봉되지 않았습니다.");
+
+    private final String statusMessage;
+
+    CapsuleOpenStatus(String statusMessage) {
+        this.statusMessage = statusMessage;
+    }
+}
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/dto/GroupCapsuleOpenStateDto.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/dto/GroupCapsuleOpenStateDto.java
new file mode 100644
index 000000000..56fd18e2a
--- /dev/null
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/dto/GroupCapsuleOpenStateDto.java
@@ -0,0 +1,23 @@
+package site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto;
+
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.response.GroupCapsuleOpenStateResponse;
+
+public record GroupCapsuleOpenStateDto(
+    CapsuleOpenStatus capsuleOpenStatus
+) {
+
+    public static GroupCapsuleOpenStateDto opened() {
+        return new GroupCapsuleOpenStateDto(CapsuleOpenStatus.OPEN);
+    }
+
+    public static GroupCapsuleOpenStateDto notOpened() {
+        return new GroupCapsuleOpenStateDto(CapsuleOpenStatus.NOT_OPEN);
+    }
+
+    public GroupCapsuleOpenStateResponse toResponse() {
+        return new GroupCapsuleOpenStateResponse(
+            capsuleOpenStatus,
+            capsuleOpenStatus.getStatusMessage()
+        );
+    }
+}
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/response/GroupCapsuleOpenStateResponse.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/response/GroupCapsuleOpenStateResponse.java
new file mode 100644
index 000000000..e77ec5c3a
--- /dev/null
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/data/response/GroupCapsuleOpenStateResponse.java
@@ -0,0 +1,10 @@
+package site.timecapsulearchive.core.domain.capsule.group_capsule.data.response;
+
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.CapsuleOpenStatus;
+
+public record GroupCapsuleOpenStateResponse(
+    CapsuleOpenStatus capsuleOpenStatus,
+    String statusMessage
+) {
+
+}
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepository.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepository.java
index d6e6d03f2..218d84b9b 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepository.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepository.java
@@ -1,8 +1,5 @@
 package site.timecapsulearchive.core.domain.capsule.group_capsule.repository;
 
-import static site.timecapsulearchive.core.domain.capsule.entity.QGroupCapsuleOpen.groupCapsuleOpen;
-
-import com.querydsl.jpa.impl.JPAQueryFactory;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.Timestamp;
@@ -20,7 +17,6 @@
 public class GroupCapsuleOpenQueryRepository {
 
     private final JdbcTemplate jdbcTemplate;
-    private final JPAQueryFactory jpaQueryFactory;
 
     public void bulkSave(final List<Long> groupMemberIds, final Capsule capsule) {
         jdbcTemplate.batchUpdate(
@@ -32,8 +28,10 @@ INSERT INTO group_capsule_open (
             new BatchPreparedStatementSetter() {
                 @Override
                 public void setValues(PreparedStatement ps, int i) throws SQLException {
+                    boolean isOpened = capsule.getDueDate() == null;
+
                     ps.setNull(1, Types.BIGINT);
-                    ps.setBoolean(2, false);
+                    ps.setBoolean(2, isOpened);
                     ps.setLong(3, groupMemberIds.get(i));
                     ps.setLong(4, capsule.getId());
                     ps.setTimestamp(5, Timestamp.valueOf(ZonedDateTime.now().toLocalDateTime()));
@@ -47,12 +45,4 @@ public int getBatchSize() {
             }
         );
     }
-
-    public List<Boolean> findIsOpenedByCapsuleId(final Long capsuleId) {
-        return jpaQueryFactory
-            .select(groupCapsuleOpen.isOpened)
-            .from(groupCapsuleOpen)
-            .where(groupCapsuleOpen.capsule.id.eq(capsuleId))
-            .fetch();
-    }
 }
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenRepository.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenRepository.java
index ce02c9eee..8dee93316 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenRepository.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenRepository.java
@@ -1,12 +1,9 @@
 package site.timecapsulearchive.core.domain.capsule.group_capsule.repository;
 
-import java.util.Optional;
 import org.springframework.data.repository.Repository;
 import site.timecapsulearchive.core.domain.capsule.entity.GroupCapsuleOpen;
 
 public interface GroupCapsuleOpenRepository extends Repository<GroupCapsuleOpen, Long> {
 
     void save(GroupCapsuleOpen groupCapsuleOpen);
-
-    Optional<GroupCapsuleOpen> findByMemberIdAndCapsuleId(Long memberId, Long capsuleId);
 }
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleService.java b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleService.java
index d40189ad3..d7123fe1c 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleService.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleService.java
@@ -2,7 +2,6 @@
 
 import java.time.ZoneOffset;
 import java.time.ZonedDateTime;
-import java.util.List;
 import lombok.RequiredArgsConstructor;
 import org.locationtech.jts.geom.Point;
 import org.springframework.data.domain.Slice;
@@ -10,16 +9,13 @@
 import org.springframework.transaction.annotation.Transactional;
 import site.timecapsulearchive.core.domain.capsule.entity.Capsule;
 import site.timecapsulearchive.core.domain.capsule.entity.CapsuleType;
-import site.timecapsulearchive.core.domain.capsule.entity.GroupCapsuleOpen;
 import site.timecapsulearchive.core.domain.capsule.exception.CapsuleNotFondException;
-import site.timecapsulearchive.core.domain.capsule.exception.GroupCapsuleOpenNotFoundException;
 import site.timecapsulearchive.core.domain.capsule.generic_capsule.repository.CapsuleRepository;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleCreateRequestDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleDetailDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleSummaryDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.MyGroupCapsuleDto;
-import site.timecapsulearchive.core.domain.capsule.group_capsule.repository.GroupCapsuleOpenQueryRepository;
-import site.timecapsulearchive.core.domain.capsule.group_capsule.repository.GroupCapsuleOpenRepository;
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleOpenStateDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.repository.GroupCapsuleQueryRepository;
 import site.timecapsulearchive.core.domain.capsuleskin.entity.CapsuleSkin;
 import site.timecapsulearchive.core.domain.group.entity.Group;
@@ -32,8 +28,6 @@ public class GroupCapsuleService {
 
     private final CapsuleRepository capsuleRepository;
     private final GroupCapsuleQueryRepository groupCapsuleQueryRepository;
-    private final GroupCapsuleOpenRepository groupCapsuleOpenRepository;
-    private final GroupCapsuleOpenQueryRepository groupCapsuleOpenQueryRepository;
 
     @Transactional
     public Capsule saveGroupCapsule(
@@ -103,21 +97,27 @@ public Slice<MyGroupCapsuleDto> findMyGroupCapsuleSlice(
      * @param capsuleId 개봉할 캡슐 아이디
      */
     @Transactional
-    public void openGroupCapsule(final Long memberId, final Long capsuleId) {
-        GroupCapsuleOpen groupCapsuleOpen = groupCapsuleOpenRepository.findByMemberIdAndCapsuleId(
-                memberId,
+    public GroupCapsuleOpenStateDto openGroupCapsule(final Long memberId, final Long capsuleId) {
+        Capsule groupCapsule = capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(memberId,
                 capsuleId)
-            .orElseThrow(GroupCapsuleOpenNotFoundException::new);
-        groupCapsuleOpen.open();
+            .orElseThrow(CapsuleNotFondException::new);
 
-        List<Boolean> capsuleOpens = groupCapsuleOpenQueryRepository.findIsOpenedByCapsuleId(
-            capsuleId);
+        if (!groupCapsule.canOpen()) {
+            return GroupCapsuleOpenStateDto.notOpened();
+        }
 
-        boolean allGroupMemberOpened = capsuleOpens.stream()
-            .allMatch(isOpened -> isOpened.equals(Boolean.TRUE));
-        if (allGroupMemberOpened) {
-            capsuleRepository.updateIsOpenedTrue(memberId, capsuleId);
+        if (!groupCapsule.isTimeCapsule()) {
+            groupCapsule.open();
+            return GroupCapsuleOpenStateDto.opened();
         }
+
+        boolean allGroupMemberOpened = groupCapsule.isAllGroupMemberOpened(memberId, capsuleId);
+        if (!allGroupMemberOpened) {
+            return GroupCapsuleOpenStateDto.notOpened();
+        }
+
+        groupCapsule.open();
+        return GroupCapsuleOpenStateDto.opened();
     }
 }
 
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/global/common/supplier/ZonedDateTimeSupplier.java b/backend/core/src/main/java/site/timecapsulearchive/core/global/common/supplier/ZonedDateTimeSupplier.java
new file mode 100644
index 000000000..6c82244c5
--- /dev/null
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/global/common/supplier/ZonedDateTimeSupplier.java
@@ -0,0 +1,14 @@
+package site.timecapsulearchive.core.global.common.supplier;
+
+import java.time.ZoneId;
+import java.time.ZonedDateTime;
+import java.util.function.Supplier;
+
+public class ZonedDateTimeSupplier {
+
+    private static final String TIME_ZONE = "UTC";
+
+    public static Supplier<ZonedDateTime> utc() {
+        return () -> ZonedDateTime.now(ZoneId.of(TIME_ZONE));
+    }
+}
diff --git a/backend/core/src/main/java/site/timecapsulearchive/core/global/error/ErrorCode.java b/backend/core/src/main/java/site/timecapsulearchive/core/global/error/ErrorCode.java
index 71f58e810..d753a1419 100644
--- a/backend/core/src/main/java/site/timecapsulearchive/core/global/error/ErrorCode.java
+++ b/backend/core/src/main/java/site/timecapsulearchive/core/global/error/ErrorCode.java
@@ -57,6 +57,7 @@ public enum ErrorCode {
     CAPSULE_NOT_FOUND_ERROR(404, "CAPSULE-001", "캡슐을 찾지 못하였습니다."),
     NO_CAPSULE_AUTHORITY_ERROR(403, "CAPSULE-002", "캡슐에 접근 권한이 없습니다."),
     GROUP_CAPSULE_OPEN_NOT_FOUND_ERROR(404, "CAPSULE-003", "그룹 캡슐 개봉상태를 찾을 수 없습니다."),
+    CAPSULE_OPEN_STATE_ERROR(400, "CAPSULE-004", "캡슐을 개봉할 수 없는 상태입니다."),
 
     //friend
     FRIEND_NOT_FOUND_ERROR(404, "FRIEND-001", "친구를 찾지 못하였습니다"),
diff --git a/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/CapsuleFixture.java b/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/CapsuleFixture.java
index 386ed7a1e..c9fdb0112 100644
--- a/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/CapsuleFixture.java
+++ b/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/CapsuleFixture.java
@@ -1,15 +1,21 @@
 package site.timecapsulearchive.core.common.fixture.domain;
 
+import java.lang.reflect.Field;
+import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.util.List;
+import java.util.Optional;
 import java.util.stream.IntStream;
 import site.timecapsulearchive.core.common.dependency.UnitTestDependency;
 import site.timecapsulearchive.core.domain.capsule.entity.Address;
 import site.timecapsulearchive.core.domain.capsule.entity.Capsule;
+import site.timecapsulearchive.core.domain.capsule.entity.Capsule.CapsuleBuilder;
 import site.timecapsulearchive.core.domain.capsule.entity.CapsuleType;
+import site.timecapsulearchive.core.domain.capsule.entity.GroupCapsuleOpen;
 import site.timecapsulearchive.core.domain.capsuleskin.entity.CapsuleSkin;
 import site.timecapsulearchive.core.domain.group.entity.Group;
 import site.timecapsulearchive.core.domain.member.entity.Member;
+import site.timecapsulearchive.core.global.common.supplier.ZonedDateTimeSupplier;
 import site.timecapsulearchive.core.global.geography.GeoTransformManager;
 
 public class CapsuleFixture {
@@ -28,7 +34,7 @@ public static List<Capsule> capsules(int size, Member member, CapsuleSkin capsul
 
     public static Capsule capsule(Member member, CapsuleSkin capsuleSkin, CapsuleType capsuleType) {
         return Capsule.builder()
-            .dueDate(ZonedDateTime.now())
+            .dueDate(ZonedDateTimeSupplier.utc().get())
             .title("testTitle")
             .content("testContent")
             .type(capsuleType)
@@ -53,23 +59,6 @@ private static Address getTestAddress() {
             .build();
     }
 
-    /**
-     * 그룹 캡슐의 테스트 픽스처들을 생성한다
-     *
-     * @param size        테스트 픽스처를 만들 캡슐의 개수
-     * @param member      그룹 캡슐을 생성할 멤버
-     * @param capsuleSkin 캡슐 스킨
-     * @param group       그룹
-     * @return 그룹 캡슐 테스트 픽스처
-     */
-    public static List<Capsule> groupCapsules(int size, Member member, CapsuleSkin capsuleSkin,
-        Group group) {
-        return IntStream
-            .range(0, size)
-            .mapToObj(i -> groupCapsule(member, capsuleSkin, group))
-            .toList();
-    }
-
     /**
      * 그룹 캡슐의 테스트 픽스처를 생성한다
      *
@@ -80,7 +69,7 @@ public static List<Capsule> groupCapsules(int size, Member member, CapsuleSkin c
      */
     public static Capsule groupCapsule(Member member, CapsuleSkin capsuleSkin, Group group) {
         return Capsule.builder()
-            .dueDate(ZonedDateTime.now())
+            .dueDate(ZonedDateTimeSupplier.utc().get())
             .title("testTitle")
             .content("testContent")
             .type(CapsuleType.GROUP)
@@ -91,4 +80,141 @@ public static Capsule groupCapsule(Member member, CapsuleSkin capsuleSkin, Group
             .group(group)
             .build();
     }
+
+    private static void setFieldValue(Object instance, String fieldName, Object value) {
+        try {
+            Field field = instance.getClass().getDeclaredField(fieldName);
+            field.setAccessible(true);
+            field.set(instance, value);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private static CapsuleBuilder defaultGroupCapsuleBuilder(Member member, CapsuleSkin capsuleSkin,
+        Group group) {
+        return Capsule.builder()
+            .title("testTitle")
+            .content("testContent")
+            .type(CapsuleType.GROUP)
+            .address(getTestAddress())
+            .point(geoTransformManager.changePoint4326To3857(TEST_LATITUDE, TEST_LONGITUDE))
+            .member(member)
+            .capsuleSkin(capsuleSkin)
+            .group(group);
+    }
+
+    public static Optional<Capsule> groupCapsuleSpecificTime(
+        Long memberId,
+        Long capsuleId,
+        ZonedDateTime zonedDateTime
+    ) {
+        CapsuleBuilder capsuleBuilder = getCapsuleBuilder(memberId);
+        Capsule capsule = capsuleBuilder.dueDate(zonedDateTime)
+            .build();
+
+        setFieldValue(capsule, "id", capsuleId);
+
+        return Optional.ofNullable(capsule);
+    }
+
+    private static CapsuleBuilder getCapsuleBuilder(Long memberId) {
+        Member member = MemberFixture.memberWithMemberId(memberId);
+        CapsuleSkin capsuleSkin = CapsuleSkinFixture.capsuleSkin(member);
+        Group group = GroupFixture.group();
+
+        CapsuleBuilder capsuleBuilder = defaultGroupCapsuleBuilder(member, capsuleSkin, group);
+        return capsuleBuilder;
+    }
+
+    public static Optional<Capsule> groupCapsuleNotAllMemberOpen(
+        Long memberId,
+        Long capsuleId,
+        List<Member> groupMembers
+    ) {
+        CapsuleBuilder capsuleBuilder = getCapsuleBuilder(memberId);
+        Capsule capsule = capsuleBuilder.dueDate(ZonedDateTimeSupplier.utc().get())
+            .build();
+
+        List<GroupCapsuleOpen> groupCapsuleOpens = GroupCapsuleOpenFixture.groupCapsuleOpens(false,
+            capsule, groupMembers);
+        setFieldValue(capsule, "id", capsuleId);
+        setFieldValue(capsule, "groupCapsuleOpens", groupCapsuleOpens);
+
+        return Optional.ofNullable(capsule);
+    }
+
+    public static Optional<Capsule> groupCapsuleHalfMemberOpen(
+        Long memberId,
+        Long capsuleId,
+        List<Member> groupMembers
+    ) {
+        CapsuleBuilder capsuleBuilder = getCapsuleBuilder(memberId);
+        Capsule capsule = capsuleBuilder.dueDate(ZonedDateTimeSupplier.utc().get())
+            .build();
+
+        List<GroupCapsuleOpen> groupCapsuleOpens = GroupCapsuleOpenFixture.groupCapsuleOpensNotAllOpened(
+            capsule, groupMembers);
+        setFieldValue(capsule, "id", capsuleId);
+        setFieldValue(capsule, "groupCapsuleOpens", groupCapsuleOpens);
+        return Optional.ofNullable(capsule);
+    }
+
+    public static Optional<Capsule> groupCapsuleEmptyOpen(
+        Long memberId,
+        Long capsuleId
+    ) {
+        CapsuleBuilder capsuleBuilder = getCapsuleBuilder(memberId);
+        Capsule capsule = capsuleBuilder.dueDate(ZonedDateTimeSupplier.utc().get())
+            .build();
+
+        setFieldValue(capsule, "id", capsuleId);
+
+        return Optional.ofNullable(capsule);
+    }
+
+    public static Optional<Capsule> groupCapsuleAllMemberOpen(
+        Long memberId,
+        Long capsuleId,
+        List<Member> groupMembers
+    ) {
+        CapsuleBuilder capsuleBuilder = getCapsuleBuilder(memberId);
+        Capsule capsule = capsuleBuilder.dueDate(ZonedDateTimeSupplier.utc().get())
+            .build();
+
+        List<GroupCapsuleOpen> groupCapsuleOpens = GroupCapsuleOpenFixture.groupCapsuleOpens(true,
+            capsule, groupMembers);
+        setFieldValue(capsule, "id", capsuleId);
+        setFieldValue(capsule, "groupCapsuleOpens", groupCapsuleOpens);
+
+        return Optional.ofNullable(capsule);
+    }
+
+    public static Optional<Capsule> groupCapsuleExcludeSpecificMember(
+        Long memberId,
+        Long capsuleId,
+        List<Member> groupMembers
+    ) {
+        CapsuleBuilder capsuleBuilder = getCapsuleBuilder(memberId);
+        Capsule capsule = capsuleBuilder.dueDate(ZonedDateTimeSupplier.utc().get())
+            .build();
+
+        List<GroupCapsuleOpen> groupCapsuleOpens = GroupCapsuleOpenFixture.groupCapsuleOpensNotOpenSpecificMemberId(
+            capsule, groupMembers, memberId);
+        setFieldValue(capsule, "id", capsuleId);
+        setFieldValue(capsule, "groupCapsuleOpens", groupCapsuleOpens);
+
+        return Optional.ofNullable(capsule);
+    }
+
+    public static Optional<Capsule> groupCapsuleAlreadyOpen(Long memberId, Long capsuleId) {
+        CapsuleBuilder capsuleBuilder = getCapsuleBuilder(memberId);
+        Capsule capsule = capsuleBuilder.dueDate(ZonedDateTimeSupplier.utc().get())
+            .build();
+
+        setFieldValue(capsule, "id", capsuleId);
+        setFieldValue(capsule, "isOpened", true);
+
+        return Optional.ofNullable(capsule);
+    }
 }
diff --git a/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/GroupCapsuleOpenFixture.java b/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/GroupCapsuleOpenFixture.java
index 795913fd7..e718b048e 100644
--- a/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/GroupCapsuleOpenFixture.java
+++ b/backend/core/src/test/java/site/timecapsulearchive/core/common/fixture/domain/GroupCapsuleOpenFixture.java
@@ -1,7 +1,10 @@
 package site.timecapsulearchive.core.common.fixture.domain;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Stream;
 import site.timecapsulearchive.core.domain.capsule.entity.Capsule;
 import site.timecapsulearchive.core.domain.capsule.entity.CapsuleType;
 import site.timecapsulearchive.core.domain.capsule.entity.GroupCapsuleOpen;
@@ -33,4 +36,45 @@ public static Optional<GroupCapsuleOpen> groupCapsuleOpen(int dataPrefix) {
             )
         );
     }
+
+    public static List<GroupCapsuleOpen> groupCapsuleOpensNotAllOpened(
+        Capsule capsule,
+        List<Member> groupMembers
+    ) {
+        int mid = groupMembers.size() / 2;
+        List<GroupCapsuleOpen> opened = groupCapsuleOpens(true, capsule,
+            groupMembers.subList(0, mid));
+        List<GroupCapsuleOpen> notOpened = groupCapsuleOpens(false, capsule,
+            groupMembers.subList(mid, groupMembers.size() - 1));
+
+        return Stream.of(opened, notOpened)
+            .flatMap(Collection::stream)
+            .toList();
+    }
+
+    public static List<GroupCapsuleOpen> groupCapsuleOpensNotOpenSpecificMemberId(
+        Capsule capsule,
+        List<Member> groupMembers,
+        Long memberId
+    ) {
+        List<Member> filteredMember = new ArrayList<>();
+        Member specificMember = null;
+        for (Member member : groupMembers) {
+            if (member.getId().equals(memberId)) {
+                specificMember = member;
+            } else {
+                filteredMember.add(member);
+            }
+        }
+
+        if (specificMember == null) {
+            throw new RuntimeException("멤버 리스트에 memberId를 가진 멤버가 존재하지 않습니다.");
+        }
+
+        List<GroupCapsuleOpen> result = new ArrayList<>();
+        result.add(GroupCapsuleOpen.createOf(specificMember, capsule, false));
+        result.addAll(groupCapsuleOpens(true, capsule, filteredMember));
+
+        return result;
+    }
 }
diff --git a/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepositoryTest.java b/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepositoryTest.java
index e7f245f2d..4a9c6c10d 100644
--- a/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepositoryTest.java
+++ b/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/repository/GroupCapsuleOpenQueryRepositoryTest.java
@@ -37,13 +37,11 @@ class GroupCapsuleOpenQueryRepositoryTest extends RepositoryTest {
     private List<GroupCapsuleOpen> groupCapsuleOpens;
 
     public GroupCapsuleOpenQueryRepositoryTest(
-        JPAQueryFactory jpaQueryFactory,
         JdbcTemplate jdbcTemplate,
         DataSource dataSource
     ) {
         this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
-        this.groupCapsuleOpenRepository = new GroupCapsuleOpenQueryRepository(jdbcTemplate,
-            jpaQueryFactory);
+        this.groupCapsuleOpenRepository = new GroupCapsuleOpenQueryRepository(jdbcTemplate);
     }
 
     @Transactional
diff --git a/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleServiceTest.java b/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleServiceTest.java
index c6caa072a..31e5d2ca5 100644
--- a/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleServiceTest.java
+++ b/backend/core/src/test/java/site/timecapsulearchive/core/domain/capsule/group_capsule/service/GroupCapsuleServiceTest.java
@@ -1,47 +1,44 @@
 package site.timecapsulearchive.core.domain.capsule.group_capsule.service;
 
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.SoftAssertions.assertSoftly;
 import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
 
+import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Optional;
-import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.Test;
-import site.timecapsulearchive.core.common.fixture.domain.GroupCapsuleOpenFixture;
+import site.timecapsulearchive.core.common.fixture.domain.CapsuleFixture;
+import site.timecapsulearchive.core.common.fixture.domain.MemberFixture;
 import site.timecapsulearchive.core.common.fixture.dto.CapsuleDtoFixture;
+import site.timecapsulearchive.core.domain.capsule.entity.Capsule;
+import site.timecapsulearchive.core.domain.capsule.exception.CapsuleNotFondException;
 import site.timecapsulearchive.core.domain.capsule.exception.GroupCapsuleOpenNotFoundException;
 import site.timecapsulearchive.core.domain.capsule.generic_capsule.data.dto.CapsuleDetailDto;
 import site.timecapsulearchive.core.domain.capsule.generic_capsule.repository.CapsuleRepository;
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.CapsuleOpenStatus;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleDetailDto;
-import site.timecapsulearchive.core.domain.capsule.group_capsule.repository.GroupCapsuleOpenQueryRepository;
-import site.timecapsulearchive.core.domain.capsule.group_capsule.repository.GroupCapsuleOpenRepository;
+import site.timecapsulearchive.core.domain.capsule.group_capsule.data.dto.GroupCapsuleOpenStateDto;
 import site.timecapsulearchive.core.domain.capsule.group_capsule.repository.GroupCapsuleQueryRepository;
 import site.timecapsulearchive.core.domain.group.data.dto.GroupMemberSummaryDto;
+import site.timecapsulearchive.core.domain.member.entity.Member;
 import site.timecapsulearchive.core.global.error.ErrorCode;
 
 class GroupCapsuleServiceTest {
 
     private final Long capsuleId = 1L;
+    private final Long memberId = 1L;
     private final int groupMemberCount = 3;
 
     private final CapsuleRepository capsuleRepository = mock(CapsuleRepository.class);
     private final GroupCapsuleQueryRepository groupCapsuleQueryRepository = mock(
         GroupCapsuleQueryRepository.class);
-    private final GroupCapsuleOpenRepository groupCapsuleOpenRepository = mock(
-        GroupCapsuleOpenRepository.class);
-    private final GroupCapsuleOpenQueryRepository groupCapsuleOpenQueryRepository = mock(
-        GroupCapsuleOpenQueryRepository.class);
 
     private final GroupCapsuleService groupCapsuleService = new GroupCapsuleService(
-        capsuleRepository, groupCapsuleQueryRepository, groupCapsuleOpenRepository,
-        groupCapsuleOpenQueryRepository
-    );
+        capsuleRepository, groupCapsuleQueryRepository);
 
     @Test
     void 개봉된_그룹_캡슐의_상세_내용을_볼_수_있다() {
@@ -56,7 +53,7 @@ class GroupCapsuleServiceTest {
             capsuleId);
 
         //then
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             CapsuleDetailDto detailDto = response.capsuleDetailDto();
             List<GroupMemberSummaryDto> members = response.members();
             softly.assertThat(response).isNotNull();
@@ -82,7 +79,7 @@ class GroupCapsuleServiceTest {
             capsuleId);
 
         //then
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             CapsuleDetailDto detailDto = response.capsuleDetailDto();
             List<GroupMemberSummaryDto> members = response.members();
             softly.assertThat(response).isNotNull();
@@ -108,7 +105,7 @@ class GroupCapsuleServiceTest {
             capsuleId);
 
         //then
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             CapsuleDetailDto detailDto = response.capsuleDetailDto();
             List<GroupMemberSummaryDto> members = response.members();
             softly.assertThat(response).isNotNull();
@@ -135,7 +132,7 @@ class GroupCapsuleServiceTest {
             capsuleId);
 
         //then
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             CapsuleDetailDto detailDto = response.capsuleDetailDto();
             List<GroupMemberSummaryDto> members = response.members();
             softly.assertThat(response).isNotNull();
@@ -160,7 +157,7 @@ class GroupCapsuleServiceTest {
             capsuleId);
 
         //then
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             CapsuleDetailDto detailDto = response.capsuleDetailDto();
             List<GroupMemberSummaryDto> members = response.members();
             softly.assertThat(response).isNotNull();
@@ -185,7 +182,7 @@ class GroupCapsuleServiceTest {
             capsuleId);
 
         //then
-        SoftAssertions.assertSoftly(softly -> {
+        assertSoftly(softly -> {
             CapsuleDetailDto detailDto = response.capsuleDetailDto();
             List<GroupMemberSummaryDto> members = response.members();
             softly.assertThat(response).isNotNull();
@@ -197,52 +194,158 @@ class GroupCapsuleServiceTest {
     }
 
     @Test
-    void 그룹_캡슐_개봉이_없는_캡슐을_개봉하려는_경우_예외가_발생한다() {
+    void 그룹_캡슐이_없는_경우_그룹_캡슐_개봉_시_예외가_발생한다() {
         //given
-        Long memberId = 1L;
-        Long capsuleId = 1L;
-        given(groupCapsuleOpenRepository.findByMemberIdAndCapsuleId(anyLong(), anyLong()))
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
             .willReturn(Optional.empty());
 
         //when
         //then
         assertThatThrownBy(() -> groupCapsuleService.openGroupCapsule(memberId, capsuleId))
-            .isInstanceOf(GroupCapsuleOpenNotFoundException.class)
-            .hasMessageContaining(ErrorCode.GROUP_CAPSULE_OPEN_NOT_FOUND_ERROR.getMessage());
+            .isInstanceOf(CapsuleNotFondException.class)
+            .hasMessageContaining(ErrorCode.CAPSULE_NOT_FOUND_ERROR.getMessage());
+    }
+
+    @Test
+    void 개봉일이_지나지_않아_그룹_캡슐을_열_수_없는_경우_캡슐은_개봉되지_않는다() {
+        //given
+        ZonedDateTime now = ZonedDateTime.now(ZoneId.of("UTC"));
+        Optional<Capsule> groupCapsule = CapsuleFixture.groupCapsuleSpecificTime(memberId,
+            capsuleId, now.plusYears(5));
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
+            .willReturn(groupCapsule);
+
+        //when
+        GroupCapsuleOpenStateDto groupCapsuleOpenStateDto = groupCapsuleService.openGroupCapsule(
+            memberId, capsuleId);
+
+        //then
+        assertSoftly(softly -> {
+            softly.assertThat(groupCapsule.get().getIsOpened()).isFalse();
+            softly.assertThat(groupCapsuleOpenStateDto.capsuleOpenStatus())
+                .isEqualTo(CapsuleOpenStatus.NOT_OPEN);
+        });
+    }
+
+    @Test
+    void 타임캡슐이_아닌_경우_그룹_캡슐_개봉_시_그룹_캡슐은_개봉된다() {
+        //given
+        Optional<Capsule> groupCapsule = CapsuleFixture.groupCapsuleSpecificTime(memberId,
+            capsuleId, null);
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
+            .willReturn(groupCapsule);
+
+        //when
+        GroupCapsuleOpenStateDto groupCapsuleOpenStateDto = groupCapsuleService.openGroupCapsule(
+            memberId, capsuleId);
+
+        //then
+        assertSoftly(softly -> {
+            softly.assertThat(groupCapsule.get().getIsOpened()).isTrue();
+            softly.assertThat(groupCapsuleOpenStateDto.capsuleOpenStatus())
+                .isEqualTo(CapsuleOpenStatus.OPEN);
+        });
     }
 
     @Test
     void 모든_그룹원이_캡슐을_개봉하지_않은_경우_캡슐은_개봉되지_않는다() {
         //given
-        Long memberId = 1L;
-        Long capsuleId = 1L;
-        given(groupCapsuleOpenRepository.findByMemberIdAndCapsuleId(anyLong(), anyLong()))
+        List<Member> groupMembers = MemberFixture.membersWithMemberId(memberId.intValue(), 4);
+        Optional<Capsule> groupCapsule = CapsuleFixture.groupCapsuleNotAllMemberOpen(memberId,
+            capsuleId,
+            groupMembers);
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
+            .willReturn(groupCapsule);
+
+        //when
+        GroupCapsuleOpenStateDto groupCapsuleOpenStateDto = groupCapsuleService.openGroupCapsule(
+            memberId, capsuleId);
 
-            .willReturn(GroupCapsuleOpenFixture.groupCapsuleOpen(memberId.intValue()));
-        given(groupCapsuleOpenQueryRepository.findIsOpenedByCapsuleId(anyLong()))
-            .willReturn(List.of(Boolean.FALSE, Boolean.FALSE, Boolean.TRUE));
+        //then
+        assertSoftly(softly -> {
+            softly.assertThat(groupCapsule.get().getIsOpened()).isFalse();
+            softly.assertThat(groupCapsuleOpenStateDto.capsuleOpenStatus()).isEqualTo(
+                CapsuleOpenStatus.NOT_OPEN);
+        });
+    }
+
+    @Test
+    void 일부_그룹원이_캡슐을_개봉한_경우_캡슐은_개봉되지_않는다() {
+        //given
+        List<Member> groupMembers = MemberFixture.membersWithMemberId(memberId.intValue(), 4);
+        Optional<Capsule> groupCapsule = CapsuleFixture.groupCapsuleHalfMemberOpen(memberId,
+            capsuleId,
+            groupMembers);
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
+            .willReturn(groupCapsule);
 
         //when
-        groupCapsuleService.openGroupCapsule(memberId, capsuleId);
+        GroupCapsuleOpenStateDto groupCapsuleOpenStateDto = groupCapsuleService.openGroupCapsule(
+            memberId, capsuleId);
+
+        //then
+        assertSoftly(softly -> {
+            softly.assertThat(groupCapsule.get().getIsOpened()).isFalse();
+            softly.assertThat(groupCapsuleOpenStateDto.capsuleOpenStatus()).isEqualTo(
+                CapsuleOpenStatus.NOT_OPEN);
+        });
+    }
+
+    @Test
+    void 그룹_캡슐_개봉이_없는_경우_예외가_발생한다() {
+        //given
+        Optional<Capsule> groupCapsule = CapsuleFixture.groupCapsuleEmptyOpen(memberId, capsuleId);
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
+            .willReturn(groupCapsule);
 
+        //when
         //then
-        verifyNoInteractions(capsuleRepository);
+        assertThatThrownBy(() -> groupCapsuleService.openGroupCapsule(memberId, capsuleId))
+            .isInstanceOf(GroupCapsuleOpenNotFoundException.class)
+            .hasMessageContaining(ErrorCode.GROUP_CAPSULE_OPEN_NOT_FOUND_ERROR.getMessage());
     }
 
     @Test
     void 모든_그룹원이_캡슐을_개봉한_경우_캡슐은_개봉된다() {
         //given
-        Long memberId = 1L;
-        Long capsuleId = 1L;
-        given(groupCapsuleOpenRepository.findByMemberIdAndCapsuleId(anyLong(), anyLong()))
-            .willReturn(GroupCapsuleOpenFixture.groupCapsuleOpen(memberId.intValue()));
-        given(groupCapsuleOpenQueryRepository.findIsOpenedByCapsuleId(anyLong()))
-            .willReturn(List.of(Boolean.TRUE, Boolean.TRUE, Boolean.TRUE));
+        List<Member> groupMembers = MemberFixture.membersWithMemberId(memberId.intValue(), 4);
+        Optional<Capsule> groupCapsule = CapsuleFixture.groupCapsuleAllMemberOpen(memberId,
+            capsuleId,
+            groupMembers);
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
+            .willReturn(groupCapsule);
+
+        //when
+        GroupCapsuleOpenStateDto groupCapsuleOpenStateDto = groupCapsuleService.openGroupCapsule(
+            memberId, capsuleId);
+
+        //then
+        assertSoftly(softly -> {
+            softly.assertThat(groupCapsule.get().getIsOpened()).isTrue();
+            softly.assertThat(groupCapsuleOpenStateDto.capsuleOpenStatus()).isEqualTo(
+                CapsuleOpenStatus.OPEN);
+        });
+    }
+
+    @Test
+    void 사용자를_제외한_그룹원이_캡슐을_개봉한_경우_그룹_캡슐_개봉을_시도하면_캡슐은_개봉된다() {
+        //given
+        List<Member> groupMembers = MemberFixture.membersWithMemberId(memberId.intValue(), 4);
+        Optional<Capsule> groupCapsule = CapsuleFixture.groupCapsuleExcludeSpecificMember(memberId,
+            capsuleId,
+            groupMembers);
+        given(capsuleRepository.findNotOpenedGroupCapsuleByMemberIdAndCapsuleId(anyLong(), anyLong()))
+            .willReturn(groupCapsule);
 
         //when
-        groupCapsuleService.openGroupCapsule(memberId, capsuleId);
+        GroupCapsuleOpenStateDto groupCapsuleOpenStateDto = groupCapsuleService.openGroupCapsule(
+            memberId, capsuleId);
 
         //then
-        verify(capsuleRepository, times(1)).updateIsOpenedTrue(anyLong(), anyLong());
+        assertSoftly(softly -> {
+            softly.assertThat(groupCapsule.get().getIsOpened()).isTrue();
+            softly.assertThat(groupCapsuleOpenStateDto.capsuleOpenStatus()).isEqualTo(
+                CapsuleOpenStatus.OPEN);
+        });
     }
 }