From da6ee406954c695a3298500663cafe34e5f5c59e Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Tue, 17 Sep 2024 11:19:50 +0200
Subject: [PATCH 01/11] feature(engine): add activityIdIn filter to
 HistoricProcessInstanceQuery

related to: #4618
---
 .../lib/commons/history-process-instance.ftl  |  7 +++
 .../HistoricProcessInstanceQueryDto.java      | 10 ++++
 ...icProcessInstanceRestServiceQueryTest.java | 29 ++++++++++
 .../history/HistoricProcessInstanceQuery.java |  5 ++
 .../HistoricProcessInstanceQueryImpl.java     | 13 +++++
 .../entity/HistoricProcessInstance.xml        | 27 ++++++++-
 .../history/HistoricProcessInstanceTest.java  | 56 +++++++++++++++++++
 7 files changed, 146 insertions(+), 1 deletion(-)

diff --git a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
index 086b3aacceb..1c4b51ccfeb 100644
--- a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
+++ b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
@@ -237,6 +237,13 @@
     "desc": "Only include historic process instances which belong to no tenant. Value may only be `true`, as `false` is the default behavior."
   },
 
+  "activityIdIn": {
+    "type": "array",
+    "itemType": "string",
+    "desc": "Restrict to instances that have an active activity or failing activity with one of given ids.  It works
+             similarly to the activityIdIn filter in the runtime query. ${listTypeDescription}"
+  },
+
   "executedActivityIdIn": {
     "type": "array",
     "itemType": "string",
diff --git a/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java b/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
index da4e861a544..c40ff2b28ea 100644
--- a/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
+++ b/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
@@ -109,6 +109,7 @@ public class HistoricProcessInstanceQueryDto extends AbstractQueryDto<HistoricPr
   private Boolean withoutTenantId;
   private List<String> executedActivityIdIn;
   private List<String> activeActivityIdIn;
+  private List<String> activityIdIn;
   private Boolean active;
   private Boolean suspended;
   private Boolean completed;
@@ -342,6 +343,11 @@ public void setActiveActivityIdIn(List<String> activeActivityIdIn) {
     this.activeActivityIdIn = activeActivityIdIn;
   }
 
+  @CamundaQueryParam(value = "activityIdIn", converter = StringListConverter.class)
+  public void setactivityIdIn(List<String> activityIdIn) {
+    this.activityIdIn = activityIdIn;
+  }
+
   @CamundaQueryParam(value = "executedJobAfter", converter = DateConverter.class)
   public void setExecutedJobAfter(Date executedJobAfter) {
     this.executedJobAfter = executedJobAfter;
@@ -548,6 +554,10 @@ protected void applyFilters(HistoricProcessInstanceQuery query) {
       query.activeActivityIdIn(activeActivityIdIn.toArray(new String[0]));
     }
 
+    if(activityIdIn!= null && !activityIdIn.isEmpty()) {
+      query.activityIdIn(activityIdIn.toArray(new String[0]));
+    }
+
     if (executedJobAfter != null) {
       query.executedJobAfter(executedJobAfter);
     }
diff --git a/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java b/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java
index b5734cc32f0..7ed79ed567b 100644
--- a/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java
+++ b/engine-rest/engine-rest/src/test/java/org/camunda/bpm/engine/rest/history/HistoricProcessInstanceRestServiceQueryTest.java
@@ -74,6 +74,7 @@ public class HistoricProcessInstanceRestServiceQueryTest extends AbstractRestSer
   protected static final String QUERY_PARAM_EXECUTED_ACTIVITY_IDS = "executedActivityIdIn";
   protected static final String QUERY_PARAM_ACTIVE_ACTIVITY_IDS = "activeActivityIdIn";
   protected static final String QUERY_PARAM_INCIDENT_IDS = "incidentIdIn";
+  protected static final String QUERY_PARAM_ACTIVE_OR_FAILING_ACTIVITY_IDS = "activityIdIn";
 
   @ClassRule
   public static TestContainerRule rule = new TestContainerRule();
@@ -2346,4 +2347,32 @@ public void testQueryByIncidentIdInAsPost() {
     verify(mockedQuery).incidentIdIn("1", "2");
   }
 
+  @Test
+  public void testQueryByActivityIdIn() {
+    given()
+        .queryParam(QUERY_PARAM_ACTIVE_OR_FAILING_ACTIVITY_IDS, "1,2")
+        .then().expect()
+        .statusCode(Status.OK.getStatusCode())
+        .when()
+        .get(HISTORIC_PROCESS_INSTANCE_RESOURCE_URL);
+
+    verify(mockedQuery).activityIdIn("1", "2");
+  }
+
+  @Test
+  public void testQueryByActivityIdInAsPost() {
+    Map<String, List<String>> parameters = new HashMap<String, List<String>>();
+    parameters.put(QUERY_PARAM_ACTIVE_OR_FAILING_ACTIVITY_IDS, Arrays.asList("1", "2"));
+
+    given()
+        .contentType(POST_JSON_CONTENT_TYPE)
+        .body(parameters)
+        .then().expect()
+        .statusCode(Status.OK.getStatusCode())
+        .when()
+        .post(HISTORIC_PROCESS_INSTANCE_RESOURCE_URL);
+
+    verify(mockedQuery).activityIdIn("1", "2");
+  }
+
 }
diff --git a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
index e8034aa7df9..9e4b957e366 100644
--- a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
+++ b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
@@ -440,6 +440,11 @@ public interface HistoricProcessInstanceQuery extends Query<HistoricProcessInsta
    */
   HistoricProcessInstanceQuery activeActivityIdIn(String... ids);
 
+  /**
+   * Only select historic process instances that have active activities or failing activities with given ids. 
+   */
+  HistoricProcessInstanceQuery activityIdIn(String... ids);
+
   /**
    * Only select historic process instances that executed an job after the given date.
    */
diff --git a/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java b/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java
index 96fa6793aa8..ba4a6fa7bb2 100644
--- a/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java
+++ b/engine/src/main/java/org/camunda/bpm/engine/impl/HistoricProcessInstanceQueryImpl.java
@@ -91,6 +91,7 @@ public class HistoricProcessInstanceQueryImpl extends AbstractVariableQueryImpl<
   protected boolean isTenantIdSet;
   protected String[] executedActivityIds;
   protected String[] activeActivityIds;
+  protected String[] activityIds;
   protected String state;
   protected String[] incidentIds;
 
@@ -478,6 +479,10 @@ public String[] getActiveActivityIds() {
     return activeActivityIds;
   }
 
+  public String[] getActivityIds() {
+    return activityIds;
+  }
+
   public String getBusinessKey() {
     return businessKey;
   }
@@ -781,6 +786,14 @@ public HistoricProcessInstanceQuery activeActivityIdIn(String... ids) {
     return this;
   }
 
+  @Override
+  public HistoricProcessInstanceQuery activityIdIn(String... ids) {
+    ensureNotNull(BadUserRequestException.class, "activity ids", (Object[]) ids);
+    ensureNotContainsNull(BadUserRequestException.class, "activity ids", Arrays.asList(ids));
+    this.activityIds = ids;
+    return this;
+  }
+
   @Override
   public HistoricProcessInstanceQuery active() {
     ensureNull(BadUserRequestException.class, "Already querying for historic process instance with another state", state, state);
diff --git a/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml b/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
index db97831716b..a9cfc130552 100644
--- a/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
+++ b/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
@@ -402,6 +402,7 @@
 
     <bind name="INC_JOIN" value="false" />
     <bind name="HAI_JOIN" value="false" />
+     <bind name="RU_JOB_JOIN" value="false" />
     <bind name="JOIN_TYPE" value="'inner join'" />
 
     <foreach collection="queries" item="query">
@@ -413,9 +414,13 @@
         <bind name="INC_JOIN" value="true" />
       </if>
 
-      <if test="query != null &amp;&amp; (query.executedActivityIds != null and query.executedActivityIds.length > 0) || (query.activeActivityIds != null and query.activeActivityIds.length > 0)">
+      <if test="query != null &amp;&amp; (query.executedActivityIds != null and query.executedActivityIds.length > 0) || (query.activeActivityIds != null and query.activeActivityIds.length > 0) || (query.activityIds != null and query.activityIds.length > 0)">
         <bind name="HAI_JOIN" value="true" />
       </if>
+
+    <if test="query != null &amp;&amp; (query.activityIds != null and query.activityIds.length > 0)">
+        <bind name="RU_JOB_JOIN" value="true" />
+      </if>
     </foreach>
 
     <if test="INC_JOIN">
@@ -425,6 +430,11 @@
       LEFT JOIN ${prefix}ACT_HI_ACTINST HAI
       ON HAI.PROC_INST_ID_ = SELF.ID_
     </if>
+
+    <if test="RU_JOB_JOIN">
+      LEFT JOIN ${prefix}ACT_RU_JOB RU_JOB
+      ON RU_JOB.PROCESS_INSTANCE_ID_ = SELF.PROC_INST_ID_
+    </if>
     
     <!-- actual value conditions are checked in the WHERE part; 
        however here we must join once for every variable condition.
@@ -634,6 +644,21 @@
               )
             </if>
 
+            <if test="query.activityIds != null and query.activityIds.length > 0">
+              ${queryType} (
+                  (
+                  HAI.END_TIME_ IS NULL
+                  AND HAI.ACT_ID_ IN
+                  <foreach item="activityId" index="index" collection="query.activityIds" open="(" separator="," close=")">
+                    #{activityId}
+                  </foreach>
+                  ) OR RU_JOB.FAILED_ACT_ID_ IN
+                  <foreach item="activityId" index="index" collection="query.activityIds" open="(" separator="," close=")">
+                    #{activityId}
+                  </foreach>
+                )
+            </if>
+
             <if test="query.executedActivityIds != null and query.executedActivityIds.length > 0">
               ${queryType} (
                 HAI.END_TIME_ IS NOT NULL
diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index e08efa5d1db..4e41a56ce89 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -1548,6 +1548,62 @@ public void testHistoricProcInstQueryWithActiveActivityIds() {
     assertEquals(result.get(0).getId(), processInstance.getId());
   }
 
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testHistoricProcInstQueryWithActivityIdsWithoutError() {
+    // given
+    deployment(ProcessModels.TWO_TASKS_PROCESS);
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process");
+
+    // assume
+    HistoricActivityInstance historicActivityInstance = historyService
+        .createHistoricActivityInstanceQuery()
+        .activityId("userTask1")
+        .singleResult();
+    assertNotNull(historicActivityInstance);
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn(historicActivityInstance.getActivityId())
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(1, result.size());
+    assertEquals(result.get(0).getId(), processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources = {"org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryWithIncidents.bpmn"})
+  public void testHistoricProcInstQueryWithActivityIdsWithError() {
+    // given
+    runtimeService.startProcessInstanceByKey("Process_1");
+    testHelper.executeAvailableJobs();
+
+    runtimeService.startProcessInstanceByKey("Process_1");
+
+    // assume
+    assertEquals(2, historyService.createHistoricProcessInstanceQuery().count());
+    assertEquals(2, historyService.createHistoricProcessInstanceQuery().list().size());
+
+    assertEquals(1, historyService.createHistoricProcessInstanceQuery().withIncidents().count());
+    assertEquals(1, historyService.createHistoricProcessInstanceQuery().withIncidents().list().size());
+    HistoricProcessInstance failingInstance =  historyService.createHistoricProcessInstanceQuery().withIncidents().singleResult();
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn("ServiceTask_3")
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(1, result.size());
+    assertEquals(result.get(0).getId(), failingInstance.getId());
+  }
+
   @Test
   public void testHistoricProcInstQueryWithActiveActivityIdsNull() {
     try {

From a09c5df9507f3ae79b5f47cf4dcd013a11f9124a Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Thu, 19 Sep 2024 16:09:10 +0200
Subject: [PATCH 02/11] add tests for multiple scope and when failing activity

---
 .../history/HistoricProcessInstanceTest.java  | 212 ++++++++++++++++--
 ...ngSubprocessWithAsyncBeforeTask.bpmn20.xml |  28 +++
 ...t.subprocessWithAsyncBeforeTask.bpmn20.xml |  27 +++
 ...InstanceQueryActivityIdInWithIncident.bpmn |  17 ++
 4 files changed, 269 insertions(+), 15 deletions(-)
 create mode 100644 engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml
 create mode 100644 engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml
 create mode 100644 engine/src/test/resources/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn

diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index 4e41a56ce89..ed877a35a46 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -1550,39 +1550,65 @@ public void testHistoricProcInstQueryWithActiveActivityIds() {
 
   @Test
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
-  public void testHistoricProcInstQueryWithActivityIdsWithoutError() {
+  public void testHistoricProcInstQueryWithActivityIdsWithOneId() {
     // given
+    String USER_TASK_1 = "userTask1";
     deployment(ProcessModels.TWO_TASKS_PROCESS);
-    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process");
+    runtimeService.startProcessInstanceByKey("Process");
+    runtimeService.startProcessInstanceByKey("Process");
 
-    // assume
-    HistoricActivityInstance historicActivityInstance = historyService
-        .createHistoricActivityInstanceQuery()
-        .activityId("userTask1")
-        .singleResult();
-    assertNotNull(historicActivityInstance);
+    List<Task> tasks = taskService.createTaskQuery().list();
+    assertEquals(2, tasks.size());
+    taskService.complete(tasks.get(0).getId());
 
     // when
     List<HistoricProcessInstance> result = historyService
         .createHistoricProcessInstanceQuery()
-        .activityIdIn(historicActivityInstance.getActivityId())
+        .activityIdIn(USER_TASK_1)
         .list();
 
     // then
     assertNotNull(result);
     assertEquals(1, result.size());
-    assertEquals(result.get(0).getId(), processInstance.getId());
+    assertEquals(result.get(0).getId(), tasks.get(1).getProcessInstanceId());
   }
 
   @Test
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
-  @Deployment(resources = {"org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryWithIncidents.bpmn"})
-  public void testHistoricProcInstQueryWithActivityIdsWithError() {
+  public void testHistoricProcInstQueryWithActivityIdsWithMultipleIds() {
     // given
-    runtimeService.startProcessInstanceByKey("Process_1");
+    String USER_TASK_1 = "userTask1";
+    String USER_TASK_2 = "userTask2";
+    deployment(ProcessModels.TWO_TASKS_PROCESS);
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("Process");
+
+    List<Task> tasks = taskService.createTaskQuery().list();
+    assertEquals(2, tasks.size());
+    taskService.complete(tasks.get(0).getId());
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn(USER_TASK_1, USER_TASK_2)
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(2, result.size());
+    assertThat(result.stream().map(HistoricProcessInstance::getId).collect(Collectors.toList()))
+        .containsExactlyInAnyOrder(processInstance.getId(),processInstance2.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources = {"org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn"})
+  public void testHistoricProcInstQueryWithActivityIdsWithFailingActivity() {
+    // given
+    runtimeService.startProcessInstanceByKey("failingProcess");
     testHelper.executeAvailableJobs();
 
-    runtimeService.startProcessInstanceByKey("Process_1");
+    runtimeService.startProcessInstanceByKey("failingProcess");
 
     // assume
     assertEquals(2, historyService.createHistoricProcessInstanceQuery().count());
@@ -1595,7 +1621,7 @@ public void testHistoricProcInstQueryWithActivityIdsWithError() {
     // when
     List<HistoricProcessInstance> result = historyService
         .createHistoricProcessInstanceQuery()
-        .activityIdIn("ServiceTask_3")
+        .activityIdIn("serviceTask")
         .list();
 
     // then
@@ -1604,6 +1630,162 @@ public void testHistoricProcInstQueryWithActivityIdsWithError() {
     assertEquals(result.get(0).getId(), failingInstance.getId());
   }
 
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/failingSubProcessCreateOneIncident.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfFailingSubprocess() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    testHelper.executeAvailableJobs();
+
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/failingSubProcessCreateOneIncident.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfFailingSubServiceTask() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    testHelper.executeAvailableJobs();
+
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("serviceTask").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocess.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfSubprocess() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("subprocess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    assertNotNull(task);
+    taskService.complete(task.getId());
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocess.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithActivityIdOfSubServiceTask() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("subprocess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    assertNotNull(task);
+    taskService.complete(task.getId());
+    // when
+    HistoricProcessInstance historicPI =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerTask").singleResult();
+
+    // then
+    assertThat(historicPI).isNotNull();
+    assertThat(historicPI.getId()).isEqualTo(processInstance.getId());
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithMultipleScopeAndIncident() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+
+    testHelper.executeAvailableJobs();
+
+    // when
+    List<HistoricProcessInstance> queryByInnerServiceActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerServiceTask").list();
+    List<HistoricProcessInstance>  queryBySubProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").list();
+    List<HistoricProcessInstance>  queryByOuterProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("outerTask").list();
+    List<HistoricProcessInstance> queryByOuterAndInnedActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerServiceTask", "outerTask").list();
+
+    // then
+    assertThat(queryByInnerServiceActivityId.size()).isEqualTo(1);
+    assertThat(queryByInnerServiceActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryBySubProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryBySubProcessActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryByOuterProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryByOuterProcessActivityId.get(0).getId()).isEqualTo(processInstance2.getId());
+
+    assertThat(queryByOuterAndInnedActivityId.size()).isEqualTo(2);
+    assertThat(queryByOuterAndInnedActivityId.stream()
+        .map(HistoricProcessInstance::getId)
+        .collect(Collectors.toList()))
+        .containsExactlyInAnyOrderElementsOf(Arrays.asList(processInstance.getId(), processInstance2.getId()));
+  }
+
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  @Deployment(resources={"org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml"})
+  public void shouldQueryByActivityIdInWithMultipleScope() {
+    // given
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("failingSubProcess");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("failingSubProcess");
+
+    TaskService taskService = engineRule.getTaskService();
+    Task task = taskService.createTaskQuery().processInstanceId(processInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+
+    // when
+    List<HistoricProcessInstance> queryByInnerServiceActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerTask").list();
+    List<HistoricProcessInstance>  queryBySubProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess").list();
+    List<HistoricProcessInstance>  queryByOuterProcessActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("outerTask").list();
+    List<HistoricProcessInstance> queryByOuterAndInnedActivityId =
+        historyService.createHistoricProcessInstanceQuery().activityIdIn("innerTask", "outerTask").list();
+
+    // then
+    assertThat(queryByInnerServiceActivityId.size()).isEqualTo(1);
+    assertThat(queryByInnerServiceActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryBySubProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryBySubProcessActivityId.get(0).getId()).isEqualTo(processInstance.getId());
+
+    assertThat(queryByOuterProcessActivityId.size()).isEqualTo(1);
+    assertThat(queryByOuterProcessActivityId.get(0).getId()).isEqualTo(processInstance2.getId());
+
+    assertThat(queryByOuterAndInnedActivityId.size()).isEqualTo(2);
+    assertThat(queryByOuterAndInnedActivityId.stream()
+        .map(HistoricProcessInstance::getId)
+        .collect(Collectors.toList()))
+        .containsExactlyInAnyOrderElementsOf(Arrays.asList(processInstance.getId(), processInstance2.getId()));
+  }
+
   @Test
   public void testHistoricProcInstQueryWithActiveActivityIdsNull() {
     try {
diff --git a/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml
new file mode 100644
index 00000000000..1121cdbdc15
--- /dev/null
+++ b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.failingSubprocessWithAsyncBeforeTask.bpmn20.xml
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
+             targetNamespace="Examples">
+
+  <process id="failingSubProcess" name="Failing SubProcess" isExecutable="true">
+
+    <startEvent id="start" />
+    <sequenceFlow id="flow1" sourceRef="start" targetRef="outerTask" />
+    <userTask id="outerTask" />
+    <sequenceFlow id="flow2" sourceRef="outerTask" targetRef="subProcess" />
+
+    <subProcess id="subProcess">
+      <startEvent id="subProcessStart" />
+      <sequenceFlow id="flow3" sourceRef="subProcessStart" targetRef="innerServiceTask" />
+      <serviceTask id="innerServiceTask" camunda:asyncBefore="true"
+                   camunda:class="org.camunda.bpm.engine.test.api.runtime.FailingDelegate" name="Service Task"/>
+      <sequenceFlow id="flow4" sourceRef="innerServiceTask" targetRef="subProcessEnd" />
+      <endEvent id="subProcessEnd" />
+    </subProcess>
+
+    <sequenceFlow id="flow5" sourceRef="subProcess" targetRef="end" />
+    <endEvent id="end" />
+
+  </process>
+
+</definitions>
diff --git a/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml
new file mode 100644
index 00000000000..a94192d7022
--- /dev/null
+++ b/engine/src/test/resources/org/camunda/bpm/engine/test/api/runtime/ProcessInstanceModificationTest.subprocessWithAsyncBeforeTask.bpmn20.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
+             targetNamespace="Examples">
+
+  <process id="failingSubProcess" name="Failing SubProcess" isExecutable="true">
+
+    <startEvent id="start" />
+    <sequenceFlow id="flow1" sourceRef="start" targetRef="outerTask" />
+    <userTask id="outerTask" />
+    <sequenceFlow id="flow2" sourceRef="outerTask" targetRef="subProcess" />
+
+    <subProcess id="subProcess">
+      <startEvent id="subProcessStart" />
+      <sequenceFlow id="flow3" sourceRef="subProcessStart" targetRef="innerTask" />
+      <userTask id="innerTask" />
+      <sequenceFlow id="flow4" sourceRef="innerTask" targetRef="subProcessEnd" />
+      <endEvent id="subProcessEnd" />
+    </subProcess>
+
+    <sequenceFlow id="flow5" sourceRef="subProcess" targetRef="end" />
+    <endEvent id="end" />
+
+  </process>
+
+</definitions>
diff --git a/engine/src/test/resources/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn b/engine/src/test/resources/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn
new file mode 100644
index 00000000000..83d72e92729
--- /dev/null
+++ b/engine/src/test/resources/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
+             xmlns:camunda="http://camunda.org/schema/1.0/bpmn"
+             targetNamespace="Examples">
+
+  <process id="failingProcess" name="Failing Process" isExecutable="true">
+
+    <startEvent id="start" />
+    <sequenceFlow id="flow1" sourceRef="start" targetRef="serviceTask" />
+    <serviceTask id="serviceTask" camunda:asyncBefore="true" camunda:class="org.camunda.bpm.engine.test.api.runtime.FailingDelegate" name="Service Task"/>
+    <sequenceFlow id="flow2" sourceRef="serviceTask" targetRef="end" />
+    <endEvent id="end" />
+
+  </process>
+
+</definitions>
\ No newline at end of file

From e3f6b7279fa7fa02e87548aa0cf908c86600553f Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Thu, 19 Sep 2024 17:06:01 +0200
Subject: [PATCH 03/11] add activityIdIn tests based on runtimeQuery test

---
 .../history/HistoricProcessInstanceTest.java  | 263 ++++++++++++++++++
 1 file changed, 263 insertions(+)

diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index ed877a35a46..d5b3df42cf8 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -36,9 +36,11 @@
 import java.util.Date;
 import java.util.GregorianCalendar;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 
+import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.time.DateUtils;
 import org.camunda.bpm.engine.BadUserRequestException;
@@ -63,11 +65,13 @@
 import org.camunda.bpm.engine.runtime.Incident;
 import org.camunda.bpm.engine.runtime.Job;
 import org.camunda.bpm.engine.runtime.ProcessInstance;
+import org.camunda.bpm.engine.runtime.ProcessInstanceQuery;
 import org.camunda.bpm.engine.task.Task;
 import org.camunda.bpm.engine.test.Deployment;
 import org.camunda.bpm.engine.test.ProcessEngineRule;
 import org.camunda.bpm.engine.test.RequiredHistoryLevel;
 import org.camunda.bpm.engine.test.api.runtime.migration.models.CallActivityModels;
+import org.camunda.bpm.engine.test.api.runtime.migration.models.CompensationModels;
 import org.camunda.bpm.engine.test.api.runtime.migration.models.ProcessModels;
 import org.camunda.bpm.engine.test.util.ProcessEngineTestRule;
 import org.camunda.bpm.engine.test.util.ProvidedProcessEngineRule;
@@ -75,6 +79,7 @@
 import org.camunda.bpm.model.bpmn.Bpmn;
 import org.camunda.bpm.model.bpmn.BpmnModelInstance;
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.RuleChain;
@@ -89,6 +94,23 @@ public class HistoricProcessInstanceTest {
   public ProcessEngineRule engineRule = new ProvidedProcessEngineRule();
   public ProcessEngineTestRule testHelper = new ProcessEngineTestRule(engineRule);
 
+  public static final BpmnModelInstance FORK_JOIN_SUB_PROCESS_MODEL = ProcessModels.newModel()
+      .startEvent()
+      .subProcess("subProcess")
+      .embeddedSubProcess()
+      .startEvent()
+      .parallelGateway("fork")
+      .userTask("userTask1")
+      .name("completeMe")
+      .parallelGateway("join")
+      .endEvent()
+      .moveToNode("fork")
+      .userTask("userTask2")
+      .connectTo("join")
+      .subProcessDone()
+      .endEvent()
+      .done();
+
   @Rule
   public RuleChain chain = RuleChain.outerRule(engineRule).around(testHelper);
 
@@ -1548,6 +1570,212 @@ public void testHistoricProcInstQueryWithActiveActivityIds() {
     assertEquals(result.get(0).getId(), processInstance.getId());
   }
 
+  @Test
+  public void testQueryByNullActivityId() {
+    try {
+      historyService.createHistoricProcessInstanceQuery().activeActivityIdIn((String[]) null).list();
+      fail("exception expected");
+    }
+    catch (BadUserRequestException e) {
+      assertThat(e.getMessage()).contains("activity ids is null");
+    }
+  }
+
+  @Test
+  public void testQueryByNullActivityIds() {
+    try {
+      historyService.createHistoricProcessInstanceQuery()
+          .activityIdIn((String[]) null);
+      fail("exception expected");
+    }
+    catch (BadUserRequestException e) {
+      assertThat(e.getMessage()).contains("activity ids is null");
+    }
+  }
+
+  @Test
+  public void testQueryByUnknownActivityId() {
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery()
+        .activityIdIn("unknown");
+
+    assertEquals(0, query.count());
+    assertEquals(0, query.list().size());
+  }
+
+  @Test
+  public void testQueryByLeafActivityId() {
+    // given
+    ProcessDefinition oneTaskDefinition = testHelper.deployAndGetDefinition(ProcessModels.ONE_TASK_PROCESS);
+    ProcessDefinition gatewaySubProcessDefinition = testHelper.deployAndGetDefinition(FORK_JOIN_SUB_PROCESS_MODEL);
+
+    // when
+    ProcessInstance oneTaskInstance1 = runtimeService.startProcessInstanceById(oneTaskDefinition.getId());
+    ProcessInstance oneTaskInstance2 = runtimeService.startProcessInstanceById(oneTaskDefinition.getId());
+    ProcessInstance gatewaySubProcessInstance1 = runtimeService.startProcessInstanceById(gatewaySubProcessDefinition.getId());
+    ProcessInstance gatewaySubProcessInstance2 = runtimeService.startProcessInstanceById(gatewaySubProcessDefinition.getId());
+
+    Task task = engineRule.getTaskService().createTaskQuery()
+        .processInstanceId(gatewaySubProcessInstance2.getId())
+        .taskName("completeMe")
+        .singleResult();
+    engineRule.getTaskService().complete(task.getId());
+
+    // then
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask");
+    assertReturnedProcessInstances(query, oneTaskInstance1, oneTaskInstance2);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask1", "userTask2");
+    assertReturnedProcessInstances(query, gatewaySubProcessInstance1, gatewaySubProcessInstance2);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask", "userTask1");
+    assertReturnedProcessInstances(query, oneTaskInstance1, oneTaskInstance2, gatewaySubProcessInstance1);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("userTask", "userTask1", "userTask2");
+    assertReturnedProcessInstances(query, oneTaskInstance1, oneTaskInstance2, gatewaySubProcessInstance1, gatewaySubProcessInstance2);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("join");
+    assertReturnedProcessInstances(query, gatewaySubProcessInstance2);
+  }
+
+  @Test
+  public void testQueryByNonLeafActivityId() {
+    // given
+    ProcessDefinition processDefinition = testHelper.deployAndGetDefinition(FORK_JOIN_SUB_PROCESS_MODEL);
+
+    // when
+    runtimeService.startProcessInstanceById(processDefinition.getId());
+
+    // then
+    ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess", "fork");
+
+    assertEquals(0, query.count());
+    assertEquals(0, query.list().size());
+  }
+
+  @Test
+  @Ignore
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testQueryByAsyncBeforeActivityId() {
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
+        .startEvent("start").camundaAsyncBefore()
+        .subProcess("subProcess").camundaAsyncBefore()
+        .embeddedSubProcess()
+        .startEvent()
+        .serviceTask("task").camundaAsyncBefore().camundaExpression("${true}")
+        .endEvent()
+        .subProcessDone()
+        .endEvent("end").camundaAsyncBefore()
+        .done()
+    );
+
+    // when
+    ProcessInstance instanceBeforeStart = runtimeService.startProcessInstanceById(testProcess.getId());
+    ProcessInstance instanceBeforeSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeSubProcess);
+    ProcessInstance instanceBeforeTask = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeTask);
+    executeJobForProcessInstance(instanceBeforeTask);
+    ProcessInstance instanceBeforeEnd = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeEnd);
+    executeJobForProcessInstance(instanceBeforeEnd);
+    executeJobForProcessInstance(instanceBeforeEnd);
+
+    // then
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertReturnedProcessInstances(query, instanceBeforeStart);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(query, instanceBeforeSubProcess);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertReturnedProcessInstances(query, instanceBeforeTask);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertReturnedProcessInstances(query, instanceBeforeEnd);
+  }
+
+  @Test
+  @Ignore
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testQueryByAsyncAfterActivityId() {
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
+        .startEvent("start").camundaAsyncAfter()
+        .subProcess("subProcess").camundaAsyncAfter()
+        .embeddedSubProcess()
+        .startEvent()
+        .serviceTask("task").camundaAsyncAfter().camundaExpression("${true}")
+        .endEvent()
+        .subProcessDone()
+        .endEvent("end").camundaAsyncAfter()
+        .done()
+    );
+
+    // when
+    ProcessInstance instanceAfterStart = runtimeService.startProcessInstanceById(testProcess.getId());
+    ProcessInstance instanceAfterTask = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterTask);
+    ProcessInstance instanceAfterSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterSubProcess);
+    executeJobForProcessInstance(instanceAfterSubProcess);
+    ProcessInstance instanceAfterEnd = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterEnd);
+    executeJobForProcessInstance(instanceAfterEnd);
+    executeJobForProcessInstance(instanceAfterEnd);
+
+    // then
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertReturnedProcessInstances(query, instanceAfterStart);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertReturnedProcessInstances(query, instanceAfterTask);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(query, instanceAfterSubProcess);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertReturnedProcessInstances(query, instanceAfterEnd);
+  }
+
+  @Test
+  public void testQueryByActivityIdBeforeCompensation() {
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
+
+    // when
+    runtimeService.startProcessInstanceById(testProcess.getId());
+    testHelper.completeTask("userTask1");
+
+    // then
+    ProcessInstanceQuery query = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+
+    assertEquals(0, query.count());
+    assertEquals(0, query.list().size());  }
+
+  @Test
+  @Ignore
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testQueryByActivityIdDuringCompensation() {
+    // given
+    ProcessDefinition testProcess = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
+
+    // when
+    ProcessInstance processInstance = runtimeService.startProcessInstanceById(testProcess.getId());
+    testHelper.completeTask("userTask1");
+    testHelper.completeTask("userTask2");
+
+    // then
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(query, processInstance);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationEvent");
+    assertReturnedProcessInstances(query, processInstance);
+
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationHandler");
+    assertReturnedProcessInstances(query, processInstance);
+  }
+
   @Test
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
   public void testHistoricProcInstQueryWithActivityIdsWithOneId() {
@@ -2343,4 +2571,39 @@ protected void executeJob(Job job) {
     }
   }
 
+
+  protected void assertReturnedProcessInstances(HistoricProcessInstanceQuery query, ProcessInstance... processInstances) {
+    int expectedSize = processInstances.length;
+    assertEquals(expectedSize, query.count());
+    assertEquals(expectedSize, query.list().size());
+
+    verifyResultContainsExactly(query.list(), collectProcessInstanceIds(Arrays.asList(processInstances)));
+  }
+
+  protected void verifyResultContainsExactly(List<HistoricProcessInstance> instances, Set<String> processInstanceIds) {
+    Set<String> retrievedInstanceIds = collectHistoricProcessInstanceIds(instances);
+    assertEquals(processInstanceIds, retrievedInstanceIds);
+  }
+
+  protected Set<String> collectProcessInstanceIds(List<ProcessInstance> instances) {
+    Set<String> retrievedInstanceIds = new HashSet<>();
+    for (ProcessInstance instance : instances) {
+      retrievedInstanceIds.add(instance.getId());
+    }
+    return retrievedInstanceIds;
+  }
+
+  protected Set<String> collectHistoricProcessInstanceIds(List<HistoricProcessInstance> instances) {
+    Set<String> retrievedInstanceIds = new HashSet<>();
+    for (HistoricProcessInstance instance : instances) {
+      retrievedInstanceIds.add(instance.getId());
+    }
+    return retrievedInstanceIds;
+  }
+
+  protected void executeJobForProcessInstance(ProcessInstance processInstance) {
+    Job job = managementService.createJobQuery().processInstanceId(processInstance.getId()).singleResult();
+    managementService.executeJob(job.getId());
+  }
+
 }

From 211ebc462b66ba399cfbdd6c29e61502bde8a937 Mon Sep 17 00:00:00 2001
From: Gergely Juhasz <gergely.juhasz@camunda.com>
Date: Thu, 19 Sep 2024 17:06:59 +0200
Subject: [PATCH 04/11] Update
 engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java

Co-authored-by: yanavasileva <yanavasileva@users.noreply.github.com>
---
 .../rest/dto/history/HistoricProcessInstanceQueryDto.java       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java b/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
index c40ff2b28ea..c944c2288ed 100644
--- a/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
+++ b/engine-rest/engine-rest/src/main/java/org/camunda/bpm/engine/rest/dto/history/HistoricProcessInstanceQueryDto.java
@@ -344,7 +344,7 @@ public void setActiveActivityIdIn(List<String> activeActivityIdIn) {
   }
 
   @CamundaQueryParam(value = "activityIdIn", converter = StringListConverter.class)
-  public void setactivityIdIn(List<String> activityIdIn) {
+  public void setActivityIdIn(List<String> activityIdIn) {
     this.activityIdIn = activityIdIn;
   }
 

From a1a554bddf9c9da2080746b7f0d005aea2fc46ad Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Thu, 19 Sep 2024 17:25:07 +0200
Subject: [PATCH 05/11] test activityIdIn filter whith deleted / completed
 instances

---
 .../history/HistoricProcessInstanceTest.java  | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index d5b3df42cf8..b0245bfc029 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -1828,6 +1828,43 @@ public void testHistoricProcInstQueryWithActivityIdsWithMultipleIds() {
         .containsExactlyInAnyOrder(processInstance.getId(),processInstance2.getId());
   }
 
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void testHistoricProcInstQueryWithActivityIdsWhenDeletedCompetedInstancesExist() {
+    // given
+    String USER_TASK_1 = "userTask1";
+    String USER_TASK_2 = "userTask2";
+    deployment(ProcessModels.TWO_TASKS_PROCESS);
+    ProcessInstance processInstance = runtimeService.startProcessInstanceByKey("Process");
+    ProcessInstance processInstance2 = runtimeService.startProcessInstanceByKey("Process");
+
+    List<Task> tasks = taskService.createTaskQuery().list();
+    assertEquals(2, tasks.size());
+    taskService.complete(tasks.get(0).getId());
+
+    ProcessInstance completedProcessInstance = runtimeService.startProcessInstanceByKey("Process");
+    Task task = taskService.createTaskQuery().processInstanceId(completedProcessInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+    task = taskService.createTaskQuery().processInstanceId(completedProcessInstance.getId()).singleResult();
+    taskService.complete(task.getId());
+
+
+    ProcessInstance deletedProcessInstance = runtimeService.startProcessInstanceByKey("Process");
+    runtimeService.deleteProcessInstance(deletedProcessInstance.getId(), "Testing");
+
+    // when
+    List<HistoricProcessInstance> result = historyService
+        .createHistoricProcessInstanceQuery()
+        .activityIdIn(USER_TASK_1, USER_TASK_2)
+        .list();
+
+    // then
+    assertNotNull(result);
+    assertEquals(2, result.size());
+    assertThat(result.stream().map(HistoricProcessInstance::getId).collect(Collectors.toList()))
+        .containsExactlyInAnyOrder(processInstance.getId(), processInstance2.getId());
+  }
+
   @Test
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
   @Deployment(resources = {"org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.testHistoricProcessInstanceQueryActivityIdInWithIncident.bpmn"})

From 853438f99888c12f2394c265374e61a86480e2d2 Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Thu, 19 Sep 2024 21:49:58 +0200
Subject: [PATCH 06/11] update test for activityIdIn where AsyncBefore,
 AsyncAfter or Compensation is used

---
 .../history/HistoricProcessInstanceTest.java  | 118 ++++++++++--------
 1 file changed, 68 insertions(+), 50 deletions(-)

diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index b0245bfc029..ee10815c87e 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -58,6 +58,8 @@
 import org.camunda.bpm.engine.history.HistoricProcessInstance;
 import org.camunda.bpm.engine.history.HistoricProcessInstanceQuery;
 import org.camunda.bpm.engine.history.HistoricVariableInstance;
+import org.camunda.bpm.engine.history.NativeHistoricActivityInstanceQuery;
+import org.camunda.bpm.engine.history.NativeHistoricProcessInstanceQuery;
 import org.camunda.bpm.engine.impl.history.HistoryLevel;
 import org.camunda.bpm.engine.impl.history.event.HistoricProcessInstanceEventEntity;
 import org.camunda.bpm.engine.impl.util.ClockUtil;
@@ -1653,9 +1655,14 @@ public void testQueryByNonLeafActivityId() {
   }
 
   @Test
-  @Ignore
+//  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
-  public void testQueryByAsyncBeforeActivityId() {
+  public void testQueryByAsyncBeforeActivityId_ACT_HI_ACTINST_NOT_POPULATED_FOR_AsyncBefore() {
+    // For the historic instance when AsyncBefore is used the historic activity is only created when the execution is scheduled
+    // For process instances that have a token just before a AsyncBefore activity
+    // In the runtimeInstanceQuery activityIdIn filter returns instances that are not scheduled yet
+    // In historicInstanceQuery activityIdIn filter does not return instances that are not scheduled yet
+
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
         .startEvent("start").camundaAsyncBefore()
@@ -1669,73 +1676,69 @@ public void testQueryByAsyncBeforeActivityId() {
         .done()
     );
 
+
+    String sql = "SELECT HIP.* FROM ACT_HI_PROCINST HIP " +
+        "LEFT JOIN ACT_HI_ACTINST HAI ON HAI.PROC_INST_ID_ = HIP.ID_ " +
+        "WHERE HAI.PROC_INST_ID_ IS NULL";
+    NativeHistoricProcessInstanceQuery processInstanceWithoutActivity = historyService.createNativeHistoricProcessInstanceQuery()
+        .sql(sql);
     // when
     ProcessInstance instanceBeforeStart = runtimeService.startProcessInstanceById(testProcess.getId());
-    ProcessInstance instanceBeforeSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
-    executeJobForProcessInstance(instanceBeforeSubProcess);
-    ProcessInstance instanceBeforeTask = runtimeService.startProcessInstanceById(testProcess.getId());
-    executeJobForProcessInstance(instanceBeforeTask);
-    executeJobForProcessInstance(instanceBeforeTask);
-    ProcessInstance instanceBeforeEnd = runtimeService.startProcessInstanceById(testProcess.getId());
-    executeJobForProcessInstance(instanceBeforeEnd);
-    executeJobForProcessInstance(instanceBeforeEnd);
-    executeJobForProcessInstance(instanceBeforeEnd);
 
-    // then
-    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
-    assertReturnedProcessInstances(query, instanceBeforeStart);
+    List<HistoricProcessInstance> historicProcessInstancesWithoutActivity =  processInstanceWithoutActivity.list();
+    assertEquals(1, historicProcessInstancesWithoutActivity.size());
+
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
-    assertReturnedProcessInstances(query, instanceBeforeSubProcess);
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
-    assertReturnedProcessInstances(query, instanceBeforeTask);
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
-    assertReturnedProcessInstances(query, instanceBeforeEnd);
+    ProcessInstance instanceBeforeSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+
+    historicProcessInstancesWithoutActivity =  processInstanceWithoutActivity.list();
+    assertEquals(2, historicProcessInstancesWithoutActivity.size());
+    assertEquals(2, historyService.createHistoricProcessInstanceQuery().list().size());
   }
 
   @Test
-  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
-  public void testQueryByAsyncAfterActivityId() {
+  public void testQueryByAsyncAfterActivityId_ACT_HI_ACTINST_END_DATE_SET_FOR_AsyncAfter() {
+    // For the historic activity the end time is set and the activity is not considered active anymore,
+    //    this is not changed if AsyncAfter is used
+    // For the runtime query the execution is still visible if AsyncAfter is used (I assume we delete the execution when scheduling next activity)
+
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
         .startEvent("start").camundaAsyncAfter()
         .subProcess("subProcess").camundaAsyncAfter()
         .embeddedSubProcess()
-        .startEvent()
+        .startEvent("innerStartEvent")
         .serviceTask("task").camundaAsyncAfter().camundaExpression("${true}")
-        .endEvent()
+        .endEvent("innerEndEvent")
         .subProcessDone()
         .endEvent("end").camundaAsyncAfter()
         .done()
     );
 
-    // when
     ProcessInstance instanceAfterStart = runtimeService.startProcessInstanceById(testProcess.getId());
-    ProcessInstance instanceAfterTask = runtimeService.startProcessInstanceById(testProcess.getId());
-    executeJobForProcessInstance(instanceAfterTask);
-    ProcessInstance instanceAfterSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
-    executeJobForProcessInstance(instanceAfterSubProcess);
-    executeJobForProcessInstance(instanceAfterSubProcess);
-    ProcessInstance instanceAfterEnd = runtimeService.startProcessInstanceById(testProcess.getId());
-    executeJobForProcessInstance(instanceAfterEnd);
-    executeJobForProcessInstance(instanceAfterEnd);
-    executeJobForProcessInstance(instanceAfterEnd);
 
-    // then
-    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
-    assertReturnedProcessInstances(query, instanceAfterStart);
+    HistoricProcessInstance historicInstanceOnStartActivity = historyService.createHistoricProcessInstanceQuery().activityIdIn("start").singleResult();
+    assertNull(historicInstanceOnStartActivity);
+    ProcessInstance instanceOnStartActivity = runtimeService.createProcessInstanceQuery().activityIdIn("start").singleResult();
+    assertNotNull(instanceOnStartActivity);
+
+    historicInstanceOnStartActivity = historyService.createHistoricProcessInstanceQuery().activeActivityIdIn("start").singleResult();
+    assertNull(historicInstanceOnStartActivity);
+
+    HistoricProcessInstance instanceExecutedStartActivity = historyService.createHistoricProcessInstanceQuery().executedActivityIdIn("start").singleResult();
+    assertEquals(instanceExecutedStartActivity.getId(), instanceAfterStart.getId());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
-    assertReturnedProcessInstances(query, instanceAfterTask);
+    NativeHistoricActivityInstanceQuery activity_query = historyService.createNativeHistoricActivityInstanceQuery()
+        .sql("SELECT * FROM ACT_HI_ACTINST");
+    List<HistoricActivityInstance> activityInstances = activity_query.list();
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
-    assertReturnedProcessInstances(query, instanceAfterSubProcess);
+    assertEquals(1, activityInstances.size());
+    assertEquals(instanceAfterStart.getId(), activityInstances.get(0).getProcessInstanceId());
+    assertNotNull(activityInstances.get(0).getEndTime());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
-    assertReturnedProcessInstances(query, instanceAfterEnd);
   }
 
   @Test
@@ -1754,9 +1757,13 @@ public void testQueryByActivityIdBeforeCompensation() {
     assertEquals(0, query.list().size());  }
 
   @Test
-  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
   public void testQueryByActivityIdDuringCompensation() {
+    // After completing user task we are expecting "subProcess", "compensationEvent", "compensationHandler" to have an activity
+    // Based on historic data only "compensationEvent", "compensationHandler" have active events
+
+    // I assume this is similar to async before where we wait for job executor to start "subProcess" for the compensation
+
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
 
@@ -1765,15 +1772,26 @@ public void testQueryByActivityIdDuringCompensation() {
     testHelper.completeTask("userTask1");
     testHelper.completeTask("userTask2");
 
-    // then
     HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
-    assertReturnedProcessInstances(query, processInstance);
-
+    assertNull(query.singleResult());
     query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationEvent");
-    assertReturnedProcessInstances(query, processInstance);
-
+    assertEquals(query.singleResult().getId(), processInstance.getId());
     query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationHandler");
-    assertReturnedProcessInstances(query, processInstance);
+    assertEquals(query.singleResult().getId(), processInstance.getId());
+
+    NativeHistoricActivityInstanceQuery activity_query = historyService.createNativeHistoricActivityInstanceQuery()
+        .sql("SELECT * FROM ACT_HI_ACTINST where END_TIME_ is null");
+    List<HistoricActivityInstance> activityInstances = activity_query.list();
+    assertEquals(2, activityInstances.size());
+    assertThat(
+        Arrays.asList(activityInstances.get(0).getActivityId(), activityInstances.get(0).getActivityId())
+            .containsAll(
+                Arrays.asList("compensationEvent", "compensationHandler")));
+
+    activity_query = historyService.createNativeHistoricActivityInstanceQuery().sql("SELECT * FROM ACT_HI_ACTINST WHERE ACT_NAME_ = 'subProcess'");
+    activityInstances = activity_query.list();
+    assertEquals(1, activityInstances.size());
+    assertNotNull(activityInstances.get(0).getEndTime());
   }
 
   @Test

From bd259a63f784204dbe41b103eeee86a6633bedf4 Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Fri, 20 Sep 2024 08:04:58 +0200
Subject: [PATCH 07/11] Revert "update test for activityIdIn where AsyncBefore,
 AsyncAfter or Compensation is used"

This reverts commit 416869547d5ea1338ff0b2ff1e81c2f4ee560a46.
---
 .../history/HistoricProcessInstanceTest.java  | 118 ++++++++----------
 1 file changed, 50 insertions(+), 68 deletions(-)

diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index ee10815c87e..b0245bfc029 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -58,8 +58,6 @@
 import org.camunda.bpm.engine.history.HistoricProcessInstance;
 import org.camunda.bpm.engine.history.HistoricProcessInstanceQuery;
 import org.camunda.bpm.engine.history.HistoricVariableInstance;
-import org.camunda.bpm.engine.history.NativeHistoricActivityInstanceQuery;
-import org.camunda.bpm.engine.history.NativeHistoricProcessInstanceQuery;
 import org.camunda.bpm.engine.impl.history.HistoryLevel;
 import org.camunda.bpm.engine.impl.history.event.HistoricProcessInstanceEventEntity;
 import org.camunda.bpm.engine.impl.util.ClockUtil;
@@ -1655,14 +1653,9 @@ public void testQueryByNonLeafActivityId() {
   }
 
   @Test
-//  @Ignore
+  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
-  public void testQueryByAsyncBeforeActivityId_ACT_HI_ACTINST_NOT_POPULATED_FOR_AsyncBefore() {
-    // For the historic instance when AsyncBefore is used the historic activity is only created when the execution is scheduled
-    // For process instances that have a token just before a AsyncBefore activity
-    // In the runtimeInstanceQuery activityIdIn filter returns instances that are not scheduled yet
-    // In historicInstanceQuery activityIdIn filter does not return instances that are not scheduled yet
-
+  public void testQueryByAsyncBeforeActivityId() {
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
         .startEvent("start").camundaAsyncBefore()
@@ -1676,69 +1669,73 @@ public void testQueryByAsyncBeforeActivityId_ACT_HI_ACTINST_NOT_POPULATED_FOR_As
         .done()
     );
 
-
-    String sql = "SELECT HIP.* FROM ACT_HI_PROCINST HIP " +
-        "LEFT JOIN ACT_HI_ACTINST HAI ON HAI.PROC_INST_ID_ = HIP.ID_ " +
-        "WHERE HAI.PROC_INST_ID_ IS NULL";
-    NativeHistoricProcessInstanceQuery processInstanceWithoutActivity = historyService.createNativeHistoricProcessInstanceQuery()
-        .sql(sql);
     // when
     ProcessInstance instanceBeforeStart = runtimeService.startProcessInstanceById(testProcess.getId());
+    ProcessInstance instanceBeforeSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeSubProcess);
+    ProcessInstance instanceBeforeTask = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeTask);
+    executeJobForProcessInstance(instanceBeforeTask);
+    ProcessInstance instanceBeforeEnd = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceBeforeEnd);
+    executeJobForProcessInstance(instanceBeforeEnd);
+    executeJobForProcessInstance(instanceBeforeEnd);
 
-    List<HistoricProcessInstance> historicProcessInstancesWithoutActivity =  processInstanceWithoutActivity.list();
-    assertEquals(1, historicProcessInstancesWithoutActivity.size());
-
-
+    // then
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertReturnedProcessInstances(query, instanceBeforeStart);
 
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(query, instanceBeforeSubProcess);
 
-    ProcessInstance instanceBeforeSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertReturnedProcessInstances(query, instanceBeforeTask);
 
-    historicProcessInstancesWithoutActivity =  processInstanceWithoutActivity.list();
-    assertEquals(2, historicProcessInstancesWithoutActivity.size());
-    assertEquals(2, historyService.createHistoricProcessInstanceQuery().list().size());
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertReturnedProcessInstances(query, instanceBeforeEnd);
   }
 
   @Test
+  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
-  public void testQueryByAsyncAfterActivityId_ACT_HI_ACTINST_END_DATE_SET_FOR_AsyncAfter() {
-    // For the historic activity the end time is set and the activity is not considered active anymore,
-    //    this is not changed if AsyncAfter is used
-    // For the runtime query the execution is still visible if AsyncAfter is used (I assume we delete the execution when scheduling next activity)
-
+  public void testQueryByAsyncAfterActivityId() {
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
         .startEvent("start").camundaAsyncAfter()
         .subProcess("subProcess").camundaAsyncAfter()
         .embeddedSubProcess()
-        .startEvent("innerStartEvent")
+        .startEvent()
         .serviceTask("task").camundaAsyncAfter().camundaExpression("${true}")
-        .endEvent("innerEndEvent")
+        .endEvent()
         .subProcessDone()
         .endEvent("end").camundaAsyncAfter()
         .done()
     );
 
+    // when
     ProcessInstance instanceAfterStart = runtimeService.startProcessInstanceById(testProcess.getId());
+    ProcessInstance instanceAfterTask = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterTask);
+    ProcessInstance instanceAfterSubProcess = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterSubProcess);
+    executeJobForProcessInstance(instanceAfterSubProcess);
+    ProcessInstance instanceAfterEnd = runtimeService.startProcessInstanceById(testProcess.getId());
+    executeJobForProcessInstance(instanceAfterEnd);
+    executeJobForProcessInstance(instanceAfterEnd);
+    executeJobForProcessInstance(instanceAfterEnd);
 
-    HistoricProcessInstance historicInstanceOnStartActivity = historyService.createHistoricProcessInstanceQuery().activityIdIn("start").singleResult();
-    assertNull(historicInstanceOnStartActivity);
-    ProcessInstance instanceOnStartActivity = runtimeService.createProcessInstanceQuery().activityIdIn("start").singleResult();
-    assertNotNull(instanceOnStartActivity);
-
-    historicInstanceOnStartActivity = historyService.createHistoricProcessInstanceQuery().activeActivityIdIn("start").singleResult();
-    assertNull(historicInstanceOnStartActivity);
-
-    HistoricProcessInstance instanceExecutedStartActivity = historyService.createHistoricProcessInstanceQuery().executedActivityIdIn("start").singleResult();
-    assertEquals(instanceExecutedStartActivity.getId(), instanceAfterStart.getId());
+    // then
+    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertReturnedProcessInstances(query, instanceAfterStart);
 
-    NativeHistoricActivityInstanceQuery activity_query = historyService.createNativeHistoricActivityInstanceQuery()
-        .sql("SELECT * FROM ACT_HI_ACTINST");
-    List<HistoricActivityInstance> activityInstances = activity_query.list();
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertReturnedProcessInstances(query, instanceAfterTask);
 
-    assertEquals(1, activityInstances.size());
-    assertEquals(instanceAfterStart.getId(), activityInstances.get(0).getProcessInstanceId());
-    assertNotNull(activityInstances.get(0).getEndTime());
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(query, instanceAfterSubProcess);
 
+    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertReturnedProcessInstances(query, instanceAfterEnd);
   }
 
   @Test
@@ -1757,13 +1754,9 @@ public void testQueryByActivityIdBeforeCompensation() {
     assertEquals(0, query.list().size());  }
 
   @Test
+  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
   public void testQueryByActivityIdDuringCompensation() {
-    // After completing user task we are expecting "subProcess", "compensationEvent", "compensationHandler" to have an activity
-    // Based on historic data only "compensationEvent", "compensationHandler" have active events
-
-    // I assume this is similar to async before where we wait for job executor to start "subProcess" for the compensation
-
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
 
@@ -1772,26 +1765,15 @@ public void testQueryByActivityIdDuringCompensation() {
     testHelper.completeTask("userTask1");
     testHelper.completeTask("userTask2");
 
+    // then
     HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
-    assertNull(query.singleResult());
+    assertReturnedProcessInstances(query, processInstance);
+
     query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationEvent");
-    assertEquals(query.singleResult().getId(), processInstance.getId());
+    assertReturnedProcessInstances(query, processInstance);
+
     query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationHandler");
-    assertEquals(query.singleResult().getId(), processInstance.getId());
-
-    NativeHistoricActivityInstanceQuery activity_query = historyService.createNativeHistoricActivityInstanceQuery()
-        .sql("SELECT * FROM ACT_HI_ACTINST where END_TIME_ is null");
-    List<HistoricActivityInstance> activityInstances = activity_query.list();
-    assertEquals(2, activityInstances.size());
-    assertThat(
-        Arrays.asList(activityInstances.get(0).getActivityId(), activityInstances.get(0).getActivityId())
-            .containsAll(
-                Arrays.asList("compensationEvent", "compensationHandler")));
-
-    activity_query = historyService.createNativeHistoricActivityInstanceQuery().sql("SELECT * FROM ACT_HI_ACTINST WHERE ACT_NAME_ = 'subProcess'");
-    activityInstances = activity_query.list();
-    assertEquals(1, activityInstances.size());
-    assertNotNull(activityInstances.get(0).getEndTime());
+    assertReturnedProcessInstances(query, processInstance);
   }
 
   @Test

From 3b0d0724da3f79d872fad1b9638056d73ff869e2 Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Fri, 20 Sep 2024 08:48:38 +0200
Subject: [PATCH 08/11] update docs and test for AsyncBefore, AsyncAfter or
 Compensation

---
 .../lib/commons/history-process-instance.ftl  |  6 +-
 .../history/HistoricProcessInstanceQuery.java |  4 +-
 .../history/HistoricProcessInstanceTest.java  | 88 +++++++++++++------
 3 files changed, 66 insertions(+), 32 deletions(-)

diff --git a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
index 1c4b51ccfeb..f60a77ffeef 100644
--- a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
+++ b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
@@ -240,8 +240,10 @@
   "activityIdIn": {
     "type": "array",
     "itemType": "string",
-    "desc": "Restrict to instances that have an active activity or failing activity with one of given ids.  It works
-             similarly to the activityIdIn filter in the runtime query. ${listTypeDescription}"
+    "desc": "Restrict to instances that have an active activity or failing activity with one of given ids. It works
+             similarly to the activityIdIn filter in the runtime query. Difference is activities that follow
+             an asyncAfter activity or themselves are asyncBefore or boundary activities are not considered active until
+             the scheduler picked them up for execution. ${listTypeDescription}"
   },
 
   "executedActivityIdIn": {
diff --git a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
index 9e4b957e366..e078319f007 100644
--- a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
+++ b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
@@ -441,7 +441,9 @@ public interface HistoricProcessInstanceQuery extends Query<HistoricProcessInsta
   HistoricProcessInstanceQuery activeActivityIdIn(String... ids);
 
   /**
-   * Only select historic process instances that have active activities or failing activities with given ids. 
+   * Only select historic process instances that have active activities or failing activities with given ids.
+   * Activities that follow an asyncAfter activity or themselves are asyncBefore or boundary activities are not
+   * considered active until the scheduler picked them up for execution.
    */
   HistoricProcessInstanceQuery activityIdIn(String... ids);
 
diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index b0245bfc029..5d54af2c6c5 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -79,7 +79,6 @@
 import org.camunda.bpm.model.bpmn.Bpmn;
 import org.camunda.bpm.model.bpmn.BpmnModelInstance;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.RuleChain;
@@ -1653,9 +1652,13 @@ public void testQueryByNonLeafActivityId() {
   }
 
   @Test
-  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
   public void testQueryByAsyncBeforeActivityId() {
+    // For a historic instance when AsyncBefore is used the historic activity is only created when the execution is scheduled
+    // For process instances that have a token just before a AsyncBefore activity
+    //  In the runtimeInstanceQuery activityIdIn filter returns instances that are not scheduled yet
+    //  In historicInstanceQuery activityIdIn filter does not return instances that are not scheduled yet
+
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
         .startEvent("start").camundaAsyncBefore()
@@ -1682,23 +1685,35 @@ public void testQueryByAsyncBeforeActivityId() {
     executeJobForProcessInstance(instanceBeforeEnd);
 
     // then
-    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
-    assertReturnedProcessInstances(query, instanceBeforeStart);
+    HistoricProcessInstanceQuery historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertNull(historicQuery.singleResult());
+    ProcessInstanceQuery runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("start");
+    assertEquals(instanceBeforeStart.getId(), runtimeQuery.singleResult().getProcessInstanceId());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
-    assertReturnedProcessInstances(query, instanceBeforeSubProcess);
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(historicQuery, instanceBeforeTask);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+    assertEquals(instanceBeforeSubProcess.getId(), runtimeQuery.singleResult().getProcessInstanceId());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
-    assertReturnedProcessInstances(query, instanceBeforeTask);
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("task");
+    assertEquals(instanceBeforeTask.getId(), runtimeQuery.singleResult().getProcessInstanceId());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
-    assertReturnedProcessInstances(query, instanceBeforeEnd);
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("end");
+    assertEquals(instanceBeforeEnd.getId(), runtimeQuery.singleResult().getProcessInstanceId());
   }
 
   @Test
-  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
   public void testQueryByAsyncAfterActivityId() {
+    // For a historic activity the end time is set after it is executed => the activity is not considered active anymore,
+    //    this is not changed if AsyncAfter is used
+    //    if the task is a subprocess end time will only be set after the subprocess is terminated
+    // For the runtime query the execution is still visible if AsyncAfter is used (I assume we delete the execution when scheduling next activity)
+
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(ProcessModels.newModel()
         .startEvent("start").camundaAsyncAfter()
@@ -1724,18 +1739,25 @@ public void testQueryByAsyncAfterActivityId() {
     executeJobForProcessInstance(instanceAfterEnd);
     executeJobForProcessInstance(instanceAfterEnd);
 
-    // then
-    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
-    assertReturnedProcessInstances(query, instanceAfterStart);
+    HistoricProcessInstanceQuery historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("start");
+    assertNull(historicQuery.singleResult());
+    ProcessInstanceQuery runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("start");
+    assertEquals(instanceAfterStart.getId(), runtimeQuery.singleResult().getProcessInstanceId());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
-    assertReturnedProcessInstances(query, instanceAfterTask);
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("task");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("task");
+    assertEquals(instanceAfterTask.getId(), runtimeQuery.singleResult().getProcessInstanceId());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
-    assertReturnedProcessInstances(query, instanceAfterSubProcess);
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertReturnedProcessInstances(historicQuery, instanceAfterTask);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+    assertEquals(instanceAfterSubProcess.getId(), runtimeQuery.singleResult().getProcessInstanceId());
 
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
-    assertReturnedProcessInstances(query, instanceAfterEnd);
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("end");
+    assertNull(historicQuery.singleResult());
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("end");
+    assertEquals(instanceAfterEnd.getId(), runtimeQuery.singleResult().getProcessInstanceId());
   }
 
   @Test
@@ -1754,9 +1776,11 @@ public void testQueryByActivityIdBeforeCompensation() {
     assertEquals(0, query.list().size());  }
 
   @Test
-  @Ignore
   @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
   public void testQueryByActivityIdDuringCompensation() {
+    // After completing user task we are expecting "subProcess", "compensationEvent", "compensationHandler" to have an activity
+    // Based on historic data only "compensationEvent", "compensationHandler" have active events
+
     // given
     ProcessDefinition testProcess = testHelper.deployAndGetDefinition(CompensationModels.COMPENSATION_ONE_TASK_SUBPROCESS_MODEL);
 
@@ -1766,14 +1790,20 @@ public void testQueryByActivityIdDuringCompensation() {
     testHelper.completeTask("userTask2");
 
     // then
-    HistoricProcessInstanceQuery query = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
-    assertReturnedProcessInstances(query, processInstance);
-
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationEvent");
-    assertReturnedProcessInstances(query, processInstance);
-
-    query = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationHandler");
-    assertReturnedProcessInstances(query, processInstance);
+    HistoricProcessInstanceQuery historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("subProcess");
+    assertNull(historicQuery.singleResult());
+    ProcessInstanceQuery runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("subProcess");
+    assertEquals(processInstance.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationEvent");
+    assertReturnedProcessInstances(historicQuery, processInstance);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("compensationEvent");
+    assertEquals(processInstance.getId(), runtimeQuery.singleResult().getProcessInstanceId());
+
+    historicQuery = historyService.createHistoricProcessInstanceQuery().activityIdIn("compensationHandler");
+    assertReturnedProcessInstances(historicQuery, processInstance);
+    runtimeQuery = runtimeService.createProcessInstanceQuery().activityIdIn("compensationEvent");
+    assertEquals(processInstance.getId(), runtimeQuery.singleResult().getProcessInstanceId());
   }
 
   @Test

From 0c4657968334c80057020973cce1461ba0ccbc1b Mon Sep 17 00:00:00 2001
From: venetrius <gergely.juhasz@camunda.com>
Date: Fri, 20 Sep 2024 12:34:25 +0200
Subject: [PATCH 09/11] update docs -> less verbose

---
 .../main/templates/lib/commons/history-process-instance.ftl  | 5 +----
 .../bpm/engine/history/HistoricProcessInstanceQuery.java     | 2 --
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
index f60a77ffeef..d910bdfdb30 100644
--- a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
+++ b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
@@ -240,10 +240,7 @@
   "activityIdIn": {
     "type": "array",
     "itemType": "string",
-    "desc": "Restrict to instances that have an active activity or failing activity with one of given ids. It works
-             similarly to the activityIdIn filter in the runtime query. Difference is activities that follow
-             an asyncAfter activity or themselves are asyncBefore or boundary activities are not considered active until
-             the scheduler picked them up for execution. ${listTypeDescription}"
+    "desc": "Restrict to instances that have an active activity or failing activity with one of the given ids. ${listTypeDescription}"
   },
 
   "executedActivityIdIn": {
diff --git a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
index e078319f007..664ba891b1f 100644
--- a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
+++ b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
@@ -442,8 +442,6 @@ public interface HistoricProcessInstanceQuery extends Query<HistoricProcessInsta
 
   /**
    * Only select historic process instances that have active activities or failing activities with given ids.
-   * Activities that follow an asyncAfter activity or themselves are asyncBefore or boundary activities are not
-   * considered active until the scheduler picked them up for execution.
    */
   HistoricProcessInstanceQuery activityIdIn(String... ids);
 

From fa47e2ee282bbc71687392fbd7e1091250cd8ebb Mon Sep 17 00:00:00 2001
From: Tassilo Weidner <3015690+tasso94@users.noreply.github.com>
Date: Fri, 20 Sep 2024 13:26:34 +0200
Subject: [PATCH 10/11] fix: join with incident instead of job to avoid bug in
 activityId filter

---
 .../entity/HistoricProcessInstance.xml        | 23 +++++------
 .../history/HistoricProcessInstanceTest.java  | 41 +++++++++++++++++++
 2 files changed, 52 insertions(+), 12 deletions(-)

diff --git a/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml b/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
index a9cfc130552..45dd2cbe23e 100644
--- a/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
+++ b/engine/src/main/resources/org/camunda/bpm/engine/impl/mapping/entity/HistoricProcessInstance.xml
@@ -173,7 +173,7 @@
 
   <update id="updateHistoricProcessInstanceByProcessInstanceId"
           parameterType="java.util.Map">
-    update 
+    update
       <if test="maxResults != null">
         ${limitBeforeWithoutOffset}
       </if>
@@ -317,7 +317,7 @@
     <result property="state" column="STATE_" jdbcType="VARCHAR"/>
     <result property="restartedProcessInstanceId" column="RESTARTED_PROC_INST_ID_" jdbcType="VARCHAR"/>
   </resultMap>
-  
+
   <resultMap type="org.camunda.bpm.engine.impl.util.ImmutablePair" id="deploymentIdMapping">
     <id property="left" column="DEPLOYMENT_ID_" jdbcType="VARCHAR" />
     <id property="right" column="ID_" jdbcType="VARCHAR" />
@@ -366,7 +366,7 @@
     <include refid="selectHistoricProcessInstancesByQueryCriteriaSql"/>
     ${countDistinctAfterEnd}
   </select>
-  
+
   <select id="selectHistoricProcessInstanceDeploymentIdMappingsByQueryCriteria" parameterType="org.camunda.bpm.engine.impl.HistoricProcessInstanceQueryImpl" resultMap="deploymentIdMapping">
     select distinct RES.DEPLOYMENT_ID_, RES.ID_
     <include refid="selectHistoricProcessInstancesByQueryCriteriaSql"/>
@@ -402,7 +402,7 @@
 
     <bind name="INC_JOIN" value="false" />
     <bind name="HAI_JOIN" value="false" />
-     <bind name="RU_JOB_JOIN" value="false" />
+    <bind name="INCACT_JOIN" value="false" />
     <bind name="JOIN_TYPE" value="'inner join'" />
 
     <foreach collection="queries" item="query">
@@ -418,8 +418,8 @@
         <bind name="HAI_JOIN" value="true" />
       </if>
 
-    <if test="query != null &amp;&amp; (query.activityIds != null and query.activityIds.length > 0)">
-        <bind name="RU_JOB_JOIN" value="true" />
+      <if test="query != null &amp;&amp; (query.activityIds != null and query.activityIds.length > 0)">
+        <bind name="INCACT_JOIN" value="true" />
       </if>
     </foreach>
 
@@ -431,12 +431,11 @@
       ON HAI.PROC_INST_ID_ = SELF.ID_
     </if>
 
-    <if test="RU_JOB_JOIN">
-      LEFT JOIN ${prefix}ACT_RU_JOB RU_JOB
-      ON RU_JOB.PROCESS_INSTANCE_ID_ = SELF.PROC_INST_ID_
+    <if test="INCACT_JOIN">
+      LEFT JOIN ${prefix}ACT_HI_INCIDENT INCACT on SELF.PROC_INST_ID_ = INCACT.PROC_INST_ID_
     </if>
-    
-    <!-- actual value conditions are checked in the WHERE part; 
+
+    <!-- actual value conditions are checked in the WHERE part;
        however here we must join once for every variable condition.
        It is important that in the WHERE part we use the same table
        names for the respective conditions (i.e. VI0, VI1, VI2, ...) -->
@@ -652,7 +651,7 @@
                   <foreach item="activityId" index="index" collection="query.activityIds" open="(" separator="," close=")">
                     #{activityId}
                   </foreach>
-                  ) OR RU_JOB.FAILED_ACT_ID_ IN
+                  ) OR INCACT.ACTIVITY_ID_ IN
                   <foreach item="activityId" index="index" collection="query.activityIds" open="(" separator="," close=")">
                     #{activityId}
                   </foreach>
diff --git a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
index 5d54af2c6c5..a342a9ff0e7 100644
--- a/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
+++ b/engine/src/test/java/org/camunda/bpm/engine/test/history/HistoricProcessInstanceTest.java
@@ -60,6 +60,7 @@
 import org.camunda.bpm.engine.history.HistoricVariableInstance;
 import org.camunda.bpm.engine.impl.history.HistoryLevel;
 import org.camunda.bpm.engine.impl.history.event.HistoricProcessInstanceEventEntity;
+import org.camunda.bpm.engine.impl.persistence.entity.JobEntity;
 import org.camunda.bpm.engine.impl.util.ClockUtil;
 import org.camunda.bpm.engine.repository.ProcessDefinition;
 import org.camunda.bpm.engine.runtime.Incident;
@@ -70,9 +71,11 @@
 import org.camunda.bpm.engine.test.Deployment;
 import org.camunda.bpm.engine.test.ProcessEngineRule;
 import org.camunda.bpm.engine.test.RequiredHistoryLevel;
+import org.camunda.bpm.engine.test.api.mgmt.FailingDelegate;
 import org.camunda.bpm.engine.test.api.runtime.migration.models.CallActivityModels;
 import org.camunda.bpm.engine.test.api.runtime.migration.models.CompensationModels;
 import org.camunda.bpm.engine.test.api.runtime.migration.models.ProcessModels;
+import org.camunda.bpm.engine.test.api.runtime.util.ChangeVariablesDelegate;
 import org.camunda.bpm.engine.test.util.ProcessEngineTestRule;
 import org.camunda.bpm.engine.test.util.ProvidedProcessEngineRule;
 import org.camunda.bpm.engine.variable.Variables;
@@ -2081,6 +2084,44 @@ public void shouldQueryByActivityIdInWithMultipleScope() {
         .containsExactlyInAnyOrderElementsOf(Arrays.asList(processInstance.getId(), processInstance2.getId()));
   }
 
+  @Test
+  @RequiredHistoryLevel(ProcessEngineConfiguration.HISTORY_FULL)
+  public void shouldQueryByActivityIdWhereIncidentOccurred() {
+    // given
+    testHelper.deploy(Bpmn.createExecutableProcess("process")
+      .startEvent()
+      .serviceTask("theTask")
+        .camundaAsyncBefore()
+        .camundaClass(ChangeVariablesDelegate.class)
+      .serviceTask("theTask2").camundaClass(ChangeVariablesDelegate.class)
+      .serviceTask("theTask3").camundaClass(FailingDelegate.class)
+      .endEvent()
+      .done());
+
+    runtimeService.startProcessInstanceByKey("process", Variables.createVariables().putValue("fail", true));
+    JobEntity job = (JobEntity) managementService.createJobQuery().singleResult();
+
+    // when: incident is raised
+    for(int i = 0; i<3; i++) {
+      try {
+        managementService.executeJob(job.getId());
+        fail("Exception expected");
+      } catch (Exception e) {
+        // exception expected
+      }
+    }
+
+    // then
+    HistoricProcessInstance theTask = historyService.createHistoricProcessInstanceQuery()
+        .activityIdIn("theTask")
+        .singleResult();
+    assertThat(theTask).isNotNull();
+    HistoricProcessInstance theTask3 = historyService.createHistoricProcessInstanceQuery()
+        .activityIdIn("theTask3")
+        .singleResult();
+    assertThat(theTask3).isNull();
+  }
+
   @Test
   public void testHistoricProcInstQueryWithActiveActivityIdsNull() {
     try {

From e6dc4375d91e094105f795cceadeceffecff800b Mon Sep 17 00:00:00 2001
From: Gergely Juhasz <gergely.juhasz@camunda.com>
Date: Fri, 20 Sep 2024 14:09:51 +0200
Subject: [PATCH 11/11] Apply suggestions from code review

Co-authored-by: tasso94 <3015690+tasso94@users.noreply.github.com>
---
 .../src/main/templates/lib/commons/history-process-instance.ftl | 2 +-
 .../bpm/engine/history/HistoricProcessInstanceQuery.java        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
index d910bdfdb30..d5532b1cf92 100644
--- a/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
+++ b/engine-rest/engine-rest-openapi/src/main/templates/lib/commons/history-process-instance.ftl
@@ -240,7 +240,7 @@
   "activityIdIn": {
     "type": "array",
     "itemType": "string",
-    "desc": "Restrict to instances that have an active activity or failing activity with one of the given ids. ${listTypeDescription}"
+    "desc": "Restrict to instances with an active activity with one of the given ids. This filter behaves differently as `activeActivityIdIn` since it also yields results when filtering for activities with an incident. ${listTypeDescription}"
   },
 
   "executedActivityIdIn": {
diff --git a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
index 664ba891b1f..46fa51c951c 100644
--- a/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
+++ b/engine/src/main/java/org/camunda/bpm/engine/history/HistoricProcessInstanceQuery.java
@@ -441,7 +441,7 @@ public interface HistoricProcessInstanceQuery extends Query<HistoricProcessInsta
   HistoricProcessInstanceQuery activeActivityIdIn(String... ids);
 
   /**
-   * Only select historic process instances that have active activities or failing activities with given ids.
+   * Only select historic process instances with an active activity with one of the given ids. This filter behaves differently as `activeActivityIdIn` since it also yields results when filtering for activities with an incident.
    */
   HistoricProcessInstanceQuery activityIdIn(String... ids);