The Unified and Autonomous Development Platform
fix: Various bugs when delete projects or reconcile issues
Robin Shen18d4becfb685
diff --git a/server-core/src/main/java/io/onedev/server/service/impl/DefaultIssueService.java b/server-core/src/main/java/io/onedev/server/service/impl/DefaultIssueService.javaindex 14956a12b4..53083e83b6 100644--- a/server-core/src/main/java/io/onedev/server/service/impl/DefaultIssueService.java+++ b/server-core/src/main/java/io/onedev/server/service/impl/DefaultIssueService.java@@ -719,39 +719,11 @@ public class DefaultIssueService extends BaseEntityService<Issue> implements Issquery.setParameter("newState", entry.getValue().getNewState());query.executeUpdate();} else {- var query = getSession().createMutationQuery("delete from IssueField where issue in (select issue from Issue issue where issue.state=:state)");- query.setParameter("state", entry.getKey());- query.executeUpdate();-- query = getSession().createMutationQuery("delete from IssueComment where issue in (select issue from Issue issue where issue.state=:state)");- query.setParameter("state", entry.getKey());- query.executeUpdate();-- query = getSession().createMutationQuery("delete from IssueChange where issue in (select issue from Issue issue where issue.state=:state)");- query.setParameter("state", entry.getKey());- query.executeUpdate();-- query = getSession().createMutationQuery("delete from IssueVote where issue in (select issue from Issue issue where issue.state=:state)");- query.setParameter("state", entry.getKey());- query.executeUpdate();-- query = getSession().createMutationQuery("delete from IssueWatch where issue in (select issue from Issue issue where issue.state=:state)");- query.setParameter("state", entry.getKey());- query.executeUpdate();-- query = getSession().createMutationQuery("delete from IssueAuthorization where issue in (select issue from Issue issue where issue.state=:state)");- query.setParameter("state", entry.getKey());- query.executeUpdate();-- query = getSession().createMutationQuery("delete from IssueStateHistory where issue in (select issue from Issue issue where issue.state=:state)");- query.setParameter("state", entry.getKey());- query.executeUpdate();-- query = getSession().createMutationQuery("delete from Issue where state=:state");- query.setParameter("state", entry.getKey());- query.executeUpdate();+ // Normal deletion checks workspaces and cascades all issue dependents.+ getSession().createQuery("from Issue where state=:state", Issue.class)+ .setParameter("state", entry.getKey()).getResultList().forEach(this::delete);- query = getSession().createMutationQuery("delete from IssueStateHistory where state=:state");+ var query = getSession().createMutationQuery("delete from IssueStateHistory where state=:state");query.setParameter("state", entry.getKey());query.executeUpdate();}diff --git a/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java b/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.javaindex bb4d8b672b..ce3a9d5b33 100644--- a/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java+++ b/server-core/src/main/java/io/onedev/server/service/impl/DefaultProjectService.java@@ -49,17 +49,6 @@ import java.util.concurrent.Future;import java.util.concurrent.locks.Lock;import java.util.function.Consumer;-import jakarta.inject.Inject;-import jakarta.inject.Singleton;-import jakarta.persistence.criteria.CriteriaBuilder;-import jakarta.persistence.criteria.CriteriaQuery;-import jakarta.persistence.criteria.From;-import jakarta.persistence.criteria.Order;-import jakarta.persistence.criteria.Path;-import jakarta.persistence.criteria.Predicate;-import jakarta.persistence.criteria.Root;-import jakarta.ws.rs.core.MediaType;-import org.apache.commons.lang3.math.NumberUtils;import org.apache.shiro.authz.UnauthorizedException;import org.apache.shiro.subject.Subject;@@ -73,7 +62,6 @@ import org.eclipse.jgit.lib.Ref;import org.eclipse.jgit.lib.Repository;import org.eclipse.jgit.lib.StoredConfig;import org.hibernate.Session;-import io.onedev.server.persistence.dao.Restrictions;import org.hibernate.query.Query;import org.hibernate.query.sqm.tree.domain.SqmPath;import org.jspecify.annotations.Nullable;@@ -135,6 +123,7 @@ import io.onedev.server.model.ProjectNumberCounter;import io.onedev.server.model.PullRequest;import io.onedev.server.model.User;import io.onedev.server.model.UserAuthorization;+import io.onedev.server.model.Workspace;import io.onedev.server.model.support.administration.GlobalProjectSetting;import io.onedev.server.model.support.code.BranchProtection;import io.onedev.server.model.support.code.GitPackConfig;@@ -144,6 +133,7 @@ import io.onedev.server.persistence.TransactionService;import io.onedev.server.persistence.annotation.Sessional;import io.onedev.server.persistence.annotation.Transactional;import io.onedev.server.persistence.dao.EntityCriteria;+import io.onedev.server.persistence.dao.Restrictions;import io.onedev.server.replica.ProjectReplica;import io.onedev.server.search.entity.EntityQuery;import io.onedev.server.search.entity.EntitySort;@@ -184,6 +174,16 @@ import io.onedev.server.web.avatar.AvatarService;import io.onedev.server.workspace.WorkspaceService;import io.onedev.server.xodus.CommitInfoService;import io.onedev.server.xodus.VisitInfoService;+import jakarta.inject.Inject;+import jakarta.inject.Singleton;+import jakarta.persistence.criteria.CriteriaBuilder;+import jakarta.persistence.criteria.CriteriaQuery;+import jakarta.persistence.criteria.From;+import jakarta.persistence.criteria.Order;+import jakarta.persistence.criteria.Path;+import jakarta.persistence.criteria.Predicate;+import jakarta.persistence.criteria.Root;+import jakarta.ws.rs.core.MediaType;@Singletonpublic class DefaultProjectService extends BaseEntityService<Project>@@ -473,6 +473,12 @@ public class DefaultProjectService extends BaseEntityService<Project>query.setParameter("fork", fork);query.setParameter("descendant", forkChild);query.executeUpdate();++ query = getSession().createMutationQuery(String.format("update Workspace set %s=:fork where %s=:descendant",+ Workspace.PROP_NUMBER_SCOPE, Workspace.PROP_PROJECT));+ query.setParameter("fork", fork);+ query.setParameter("descendant", forkChild);+ query.executeUpdate();}}@@ -485,13 +491,10 @@ public class DefaultProjectService extends BaseEntityService<Project>for (PullRequest request: project.getOutgoingRequests()) {if (!request.getTargetProject().equals(project) && request.isOpen())pullRequestService.discard(user, request, "Source project is deleted.");+ // Bulk updates leave managed requests referencing the project when Hibernate flushes.+ request.setSourceProject(null);}- query = getSession().createMutationQuery(String.format("update PullRequest set %s=null where %s=:sourceProject",- PullRequest.PROP_SOURCE_PROJECT, PullRequest.PROP_SOURCE_PROJECT));- query.setParameter("sourceProject", project);- query.executeUpdate();-for (var workspace: project.getWorkspaces())workspaceService.delete(workspace);diff --git a/server-core/src/test/java/io/onedev/server/service/impl/DeletionReferenceTest.java b/server-core/src/test/java/io/onedev/server/service/impl/DeletionReferenceTest.javanew file mode 100644index 0000000000..9088549341--- /dev/null+++ b/server-core/src/test/java/io/onedev/server/service/impl/DeletionReferenceTest.java@@ -0,0 +1,379 @@+package io.onedev.server.service.impl;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.Mockito.doAnswer;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.mockStatic;+import static org.mockito.Mockito.when;++import java.lang.reflect.Field;+import java.util.ArrayList;+import java.util.Date;+import java.util.Map;+import java.util.Set;+import java.util.UUID;+import java.util.concurrent.atomic.AtomicLong;++import org.hibernate.Session;+import org.hibernate.SessionFactory;+import org.hibernate.boot.MetadataSources;+import org.hibernate.boot.registry.StandardServiceRegistry;+import org.hibernate.boot.registry.StandardServiceRegistryBuilder;+import org.hibernate.id.IdentifierGenerator;+import org.hibernate.mapping.SimpleValue;+import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.mockito.MockedStatic;++import io.onedev.commons.utils.ClassUtils;+import io.onedev.server.OneDev;+import io.onedev.server.model.AbstractEntity;+import io.onedev.server.model.Issue;+import io.onedev.server.model.IssueComment;+import io.onedev.server.model.IssueCommentReaction;+import io.onedev.server.model.IssueLink;+import io.onedev.server.model.IssueReaction;+import io.onedev.server.model.IssueSchedule;+import io.onedev.server.model.IssueStateHistory;+import io.onedev.server.model.Iteration;+import io.onedev.server.model.LinkSpec;+import io.onedev.server.model.Project;+import io.onedev.server.model.ProjectLastActivityDate;+import io.onedev.server.model.PullRequest;+import io.onedev.server.model.User;+import io.onedev.server.model.Workspace;+import io.onedev.server.model.support.LastActivity;+import io.onedev.server.model.support.administration.GlobalIssueSetting;+import io.onedev.server.model.support.pullrequest.MergeStrategy;+import io.onedev.server.persistence.PrefixedNamingStrategy;+import io.onedev.server.persistence.dao.Dao;+import io.onedev.server.security.SecurityUtils;+import io.onedev.server.service.SettingService;+import io.onedev.server.util.usage.Usage;+import io.onedev.server.web.component.issue.workflowreconcile.UndefinedStateResolution;+import jakarta.inject.Inject;++class DeletionReferenceTest {+ private static final String HASH = "0".repeat(40);+ private static StandardServiceRegistry registry;+ private static SessionFactory factory;+ private static jakarta.validation.ValidatorFactory validatorFactory;+ private Session session;+ private User author;+ private MockedStatic<SecurityUtils> security;+ private MockedStatic<OneDev> application;+ private GlobalIssueSetting issueSetting;+ private long fixtureNumber;++ @BeforeAll+ static void createDatabase() {+ validatorFactory = jakarta.validation.Validation.buildDefaultValidatorFactory();+ registry = new StandardServiceRegistryBuilder()+ .applySetting("hibernate.connection.url", "jdbc:hsqldb:mem:deletion_" + UUID.randomUUID())+ .applySetting("hibernate.connection.username", "sa")+ .applySetting("hibernate.cache.use_second_level_cache", false)+ .applySetting("hibernate.hbm2ddl.auto", "create-drop")+ .applySetting("jakarta.persistence.validation.mode", "none").build();+ var sources = new MetadataSources(registry);+ ClassUtils.findImplementations(AbstractEntity.class, AbstractEntity.class).forEach(sources::addAnnotatedClass);+ var metadata = sources.getMetadataBuilder().applyPhysicalNamingStrategy(new PrefixedNamingStrategy("o_")).build();+ var ids = new AtomicLong();+ for (var entity : metadata.getEntityBindings()) {+ ((SimpleValue) entity.getIdentifier()).setCustomIdGeneratorCreator(context ->+ (IdentifierGenerator) (session, object) -> ids.incrementAndGet());+ }+ factory = metadata.buildSessionFactory();+ }++ @AfterAll+ static void closeDatabase() {+ if (validatorFactory != null)+ validatorFactory.close();+ if (factory != null)+ factory.close();+ StandardServiceRegistryBuilder.destroy(registry);+ }++ @BeforeEach+ void beginTransaction() {+ session = factory.withOptions()+ .interceptor(new io.onedev.server.persistence.HibernateInterceptor(Set.of())).openSession();+ session.beginTransaction();+ author = user("author");+ security = mockStatic(SecurityUtils.class);+ security.when(SecurityUtils::getUser).thenReturn(author);+ issueSetting = new GlobalIssueSetting();+ var settings = mock(SettingService.class);+ when(settings.getIssueSetting()).thenReturn(issueSetting);+ application = mockStatic(OneDev.class);+ application.when(() -> OneDev.getInstance(jakarta.validation.Validator.class)).thenReturn(validatorFactory.getValidator());+ application.when(() -> OneDev.getInstance(SettingService.class)).thenReturn(settings);+ var projects = mock(io.onedev.server.service.ProjectService.class);+ when(projects.load(any())).thenAnswer(it -> session.find(Project.class, (Long) it.getArgument(0)));+ application.when(() -> OneDev.getInstance(io.onedev.server.service.ProjectService.class)).thenReturn(projects);+ }++ @AfterEach+ void rollback() {+ session.getTransaction().rollback();+ session.close();+ if (security != null)+ security.close();+ if (application != null)+ application.close();+ }++ @Test+ void deletingProjectClearsManagedPullRequestSourceBeforeFlush() throws Exception {+ var source = project("source");+ var target = project("target");+ var request = request(target);+ request.setSourceProject(source);+ request.setStatus(PullRequest.Status.MERGED);+ session.flush();+ session.clear();+ source = session.getReference(Project.class, source.getId());+ // Project deletion loads outgoing requests; flushing must not retain the deleted source.+ service(new DefaultProjectService(Set.of())).delete(source);+ session.flush();+ session.clear();+ assertNull(session.find(Project.class, source.getId()));+ assertNull(session.find(PullRequest.class, request.getId()).getSourceProject());+ assertEquals(target.getId(), session.find(PullRequest.class, request.getId()).getTargetProject().getId());+ }++ @Test+ void deletingProjectPreservesForkWorkspaceNumberScopes() throws Exception {+ var original = project("original");+ var fork = project("fork");+ fork.setForkedFrom(original);+ var descendant = project("descendant");+ descendant.setForkedFrom(fork);+ var unrelated = project("unrelated");+ var forkWorkspace = workspace(fork, original);+ var descendantWorkspace = workspace(descendant, original);+ var unrelatedWorkspace = workspace(unrelated, unrelated);+ session.flush();+ session.clear();+ // Match ProjectResource: BaseEntityService.load obtains a Hibernate reference.+ original = session.getReference(Project.class, original.getId());++ service(new DefaultProjectService(Set.of())).delete(original);+ session.flush();+ session.clear();+ assertNull(session.find(Project.class, original.getId()));+ assertEquals(fork.getId(), session.find(Workspace.class, forkWorkspace.getId()).getNumberScope().getId());+ assertEquals(fork.getId(), session.find(Workspace.class, descendantWorkspace.getId()).getNumberScope().getId());+ assertEquals(unrelated.getId(), session.find(Workspace.class, unrelatedWorkspace.getId()).getNumberScope().getId());+ assertEquals(descendant.getId(), session.find(Workspace.class, descendantWorkspace.getId()).getProject().getId());+ }++ @Test+ void workflowDeletionCascadesReactionsAndPreservesOtherIssues() throws Exception {+ var project = project("project");+ var issue = issue(project);+ var other = issue(project); other.setState("Closed");+ var reaction = new IssueReaction(); reaction.setIssue(issue); reaction.setUser(author); reaction.setEmoji("thumbsup");+ session.persist(reaction); issue.getReactions().add(reaction);+ var comment = new IssueComment(); comment.setIssue(issue); comment.setUser(author); comment.setContent("comment");+ session.persist(comment); issue.getComments().add(comment);+ var commentReaction = new IssueCommentReaction(); commentReaction.setComment(comment); commentReaction.setUser(author); commentReaction.setEmoji("thumbsup");+ session.persist(commentReaction); comment.getReactions().add(commentReaction);+ var link = link(issue, other, linkSpec(false));+ var schedule = schedule(issue, iteration(project, "iteration"));+ var removedHistory = history(other, "Open");+ var keptHistory = history(other, "Closed");+ session.flush();+ session.clear();+ var resolution = new UndefinedStateResolution(); resolution.setFixType(UndefinedStateResolution.FixType.DELETE_THIS_STATE);+ service(new DefaultIssueService()).fixUndefinedStates(Map.of("Open", resolution));+ session.flush(); session.clear();+ assertNull(session.find(IssueLink.class, link.getId()));+ assertNull(session.find(IssueSchedule.class, schedule.getId()));+ assertNull(session.find(Issue.class, issue.getId()));+ assertNull(session.find(IssueReaction.class, reaction.getId()));+ assertNull(session.find(IssueComment.class, comment.getId()));+ assertNull(session.find(IssueCommentReaction.class, commentReaction.getId()));+ assertNull(session.find(IssueStateHistory.class, removedHistory.getId()));+ assertEquals("Closed", session.find(IssueStateHistory.class, keptHistory.getId()).getState());+ assertEquals("Closed", session.find(Issue.class, other.getId()).getState());+ }++ @Test+ void workflowDeletionStillRejectsIssuesWithWorkspaces() throws Exception {+ var issue = issue(project("project"));+ issue.getWorkspaces().add(new Workspace());+ var resolution = new UndefinedStateResolution(); resolution.setFixType(UndefinedStateResolution.FixType.DELETE_THIS_STATE);+ assertThrows(io.onedev.server.exception.NotAcceptableException.class,+ () -> service(new DefaultIssueService()).fixUndefinedStates(Map.of("Open", resolution)));+ assertTrue(session.contains(issue));+ }++ private LinkSpec linkSpec(boolean directed) {+ var spec = new LinkSpec();+ spec.setName("test-" + UUID.randomUUID());+ spec.setMultiple(true);+ if (directed) {+ var opposite = new io.onedev.server.model.support.issue.LinkSpecOpposite();+ opposite.setName("opposite-" + UUID.randomUUID());+ opposite.setMultiple(true);+ spec.setOpposite(opposite);+ }+ session.persist(spec);+ return spec;+ }++ private IssueLink link(Issue source, Issue target, LinkSpec spec) {+ var link = new IssueLink();+ link.setSource(source);+ link.setTarget(target);+ link.setSpec(spec);+ link.setPosition(1);+ session.persist(link);+ return link;+ }++ private Iteration iteration(Project project, String name) {+ var iteration = new Iteration();+ iteration.setProject(project);+ iteration.setName(name);+ session.persist(iteration);+ return iteration;+ }++ private IssueSchedule schedule(Issue issue, Iteration iteration) {+ var schedule = issue.addSchedule(iteration);+ iteration.getSchedules().add(schedule);+ session.persist(schedule);+ return schedule;+ }++ private Workspace workspace(Project project, Project numberScope) {+ var workspace = new Workspace();+ workspace.setProject(project);+ workspace.setNumberScope(numberScope);+ workspace.setNumber(++fixtureNumber);+ workspace.setUser(author);+ workspace.setSpecName("test");+ workspace.setCommitHash(HASH);+ workspace.setToken(UUID.randomUUID().toString());+ session.persist(workspace);+ return workspace;+ }++ private IssueStateHistory history(Issue issue, String state) {+ var history = new IssueStateHistory(); history.setIssue(issue); history.setState(state); history.setDate(new Date());+ session.persist(history); issue.getStateHistories().add(history); return history;+ }++ private User user(String name) {+ var user = new User();+ user.setName(name);+ session.persist(user);+ return user;+ }++ private Project project(String name) {+ var activity = new ProjectLastActivityDate();+ session.persist(activity);+ var project = new Project();+ project.setName(name);+ project.setPath(name);+ project.setLastActivityDate(activity);+ session.persist(project);+ return project;+ }++ private LastActivity activity() {+ var activity = new LastActivity();+ activity.setUser(author);+ activity.setDate(new Date());+ activity.setDescription("created");+ return activity;+ }++ private PullRequest request(Project project) {+ var request = new PullRequest();+ request.setTitle("request");+ request.setSubmitter(author);+ request.setTargetProject(project);+ request.setNumberScope(project);+ request.setSourceProject(project);+ request.setTargetBranch("main");+ request.setSourceBranch("feature");+ request.setBaseCommitHash(HASH);+ request.setMergeStrategy(MergeStrategy.CREATE_MERGE_COMMIT);+ request.setLastActivity(activity());+ request.setNumber(++fixtureNumber);+ session.persist(request);+ return request;+ }++ private Issue issue(Project project) throws Exception {+ var issue = new Issue();+ issue.setProject(project);+ issue.setNumberScope(project);+ issue.setTitle("issue");+ issue.setSubmitter(author);+ issue.setLastActivity(activity());+ var state = Issue.class.getDeclaredField("state");+ state.setAccessible(true);+ state.set(issue, "Open");+ issue.setNumber(++fixtureNumber);+ session.persist(issue);+ return issue;+ }++ private <T extends BaseEntityService<?>> T service(T service) throws Exception {+ // Keep persistence real; isolate external side effects and unrelated services.+ for (Class<?> type = service.getClass(); type != Object.class; type = type.getSuperclass()) {+ for (Field field : type.getDeclaredFields()) {+ if (field.isAnnotationPresent(Inject.class)) {+ field.setAccessible(true);+ var dependency = mock(field.getType());+ if (dependency instanceof SettingService settings) {+ when(settings.getIssueSetting()).thenReturn(issueSetting);+ when(settings.onDeleteProject(anyString())).thenReturn(new Usage());+ when(settings.onDeleteUser(anyString())).thenReturn(new Usage());+ when(settings.onDeleteGroup(anyString())).thenReturn(new Usage());+ when(settings.onDeleteLink(anyString())).thenReturn(new Usage());+ when(settings.onDeleteRole(anyString())).thenReturn(new Usage());+ }+ if (dependency instanceof io.onedev.server.service.ProjectService projects) {+ when(projects.getIds()).thenAnswer(it -> session.createQuery("select id from Project", Long.class).getResultList());+ when(projects.getSubtreeIds(any())).thenAnswer(it -> {+ var project = session.find(Project.class, (Long) it.getArgument(0));+ var subtree = new ArrayList<>(project.getDescendants());+ subtree.add(project);+ return subtree.stream().map(Project::getId).toList();+ });+ }+ if (dependency instanceof io.onedev.server.service.UserService users)+ when(users.getSystem()).thenReturn(author);+ field.set(service, dependency);+ }+ }+ }+ service.dao = mock(Dao.class);+ when(service.dao.getSession()).thenReturn(session);+ doAnswer(it -> { session.remove(it.getArgument(0)); return null; }).when(service.dao).remove(any());+ doAnswer(it -> {+ AbstractEntity entity = it.getArgument(0);+ if (entity.isNew())+ session.persist(entity);+ else if (!session.contains(entity))+ session.merge(entity);+ return null;+ }).when(service.dao).persist(any());+ return service;+ }++}