diff --git a/build.gradle b/build.gradle index 43138a0fef..c89459ce40 100644 --- a/build.gradle +++ b/build.gradle @@ -109,6 +109,19 @@ configurations { cftlibTestRuntime.extendsFrom testRuntime } +configurations.configureEach { + resolutionStrategy.eachDependency { details -> + if (details.requested.group == 'com.github.hmcts') { + if (details.requested.name == 'decentralised-runtime' + || details.requested.name == 'task-management' + || details.requested.name == 'ccd-config-generator') { + details.useVersion 'task-mgmt-40.1-46b69557' + details.because 'Ensure task-management, decentralised-runtime and ccd-config-generator stay aligned' + } + } + } +} + tasks.withType(JavaCompile) { options.compilerArgs << "-Xlint:unchecked" << "-Werror" } @@ -245,7 +258,8 @@ def sonarExclusions = [ '**/uk/gov/hmcts/sptribs/ciccase/model/UserRolesForAccessProfiles.java', '**/uk/gov/hmcts/sptribs/common/config/**', '**/uk/gov/hmcts/sptribs/common/event/UpdateCaseDataEvent.java', - '**/uk/gov/hmcts/sptribs/common/service/CaseDataFieldService.java' + '**/uk/gov/hmcts/sptribs/common/service/CaseDataFieldService.java', + '**/uk/gov/hmcts/sptribs/taskmanagement/model/**' ] sonarqube { @@ -330,6 +344,10 @@ def versions = [ dependencies { // uncomment for local version // implementation group: 'com.github.hmcts', name: 'ccd-config-generator', version: 'DEV-SNAPSHOT' +// implementation 'com.github.hmcts:task-management:DEV-SNAPSHOT' + implementation 'com.github.hmcts:task-management:task-mgmt-40.1-46b69557' + implementation 'com.github.hmcts:decentralised-runtime:task-mgmt-40.1-46b69557' + implementation 'com.github.hmcts:ccd-config-generator:task-mgmt-40.1-46b69557' implementation group: 'com.fasterxml.jackson.core', name: 'jackson-databind', version: versions.jackson implementation group: 'com.fasterxml.jackson.core', name: 'jackson-core', version: versions.jackson @@ -430,6 +448,10 @@ dependencies { // Provides fast-reload of just the sptribs service. cftlibImplementation 'org.springframework.boot:spring-boot-devtools' + cftlibTestImplementation sourceSets.test.runtimeClasspath + cftlibTestImplementation 'com.github.hmcts:task-management:task-mgmt-40.1-46b69557' + cftlibTestImplementation 'com.github.hmcts:decentralised-runtime:task-mgmt-40.1-46b69557' + cftlibTestImplementation 'com.github.hmcts:ccd-config-generator:task-mgmt-40.1-46b69557' cftlibTestImplementation 'com.microsoft.playwright:playwright:1.58.0' cftlibTestImplementation 'org.junit-pioneer:junit-pioneer:2.3.0' cftlibTestImplementation 'io.github.artsok:rerunner-jupiter:2.1.6' @@ -525,10 +547,66 @@ ccd { configDir = file('build/definitions') } +def localRseCftLibDir = file('../rse-cft-lib') +def localWaTaskManagementApiDir = file("${localRseCftLibDir}/projects/wa-task-management-api") +def localCftLibPublishingInit = file("${localRseCftLibDir}/cftlib/buildSrc/configurePublishing.gradle") +def localWaPublishingFixInit = file("$rootDir/gradle/wa-publish-fix.init.gradle") +def localWaM2Jar = file("${System.properties['user.home']}/.m2/repository/com/github/hmcts/rse-cft-lib/wa-task-management-api/0.19.2017/wa-task-management-api-0.19.2017.jar") +def useLocalWaTaskManagementApi = (project.findProperty('useLocalWaTaskManagementApi') ?: 'false').toString().toBoolean() + +tasks.register('publishLocalWaTaskManagementApiToMavenLocal', Exec) { + group = 'ccd tasks' + description = 'Publishes local WA task-management-api for cftlib (if ../rse-cft-lib is present)' + onlyIf { + useLocalWaTaskManagementApi + && localWaTaskManagementApiDir.exists() + && localCftLibPublishingInit.exists() + && localWaPublishingFixInit.exists() + } + workingDir localWaTaskManagementApiDir + commandLine './gradlew', '--no-daemon', + '-I', localCftLibPublishingInit.absolutePath, + '-I', localWaPublishingFixInit.absolutePath, + 'publishToMavenLocal' + environment 'RELEASE_VERSION', '0.19.2017' +} + tasks.withType(CftlibExec).configureEach { + dependsOn tasks.named('publishLocalWaTaskManagementApiToMavenLocal') environment 'RSE_LIB_ADDITIONAL_DATABASES', 'sptribs' environment 'CCD_DECENTRALISED_CASE-TYPE-SERVICE-URLS_CriminalInjuriesCompensation', 'http://localhost:4013' environment 'SPRING_JMS_SERVICEBUS_ENABLED', 'false' + // The IDAM simulator authorizes /api/v1/users requests only when the token subject exists in simulator memory. + // Default data-store system user is not present there, which causes 401s in cftlib parity tests. + // Keep explicit env override support for local/custom setups. + environment 'IDAM_DATA_STORE_SYSTEM_USER_USERNAME', + System.getenv('IDAM_DATA_STORE_SYSTEM_USER_USERNAME') ?: 'TEST_CASE_WORKER_USER@mailinator.com' + environment 'TASK_MANAGEMENT_EXCLUSIVE_CLIENTS', + 'wa_task_management_api,wa_task_monitor,wa_case_event_handler,wa_workflow_api,nfdiv_case_api,sptribs_case_api' + environment 'TASK_MANAGEMENT_PRIVILEGED_CLIENTS', + 'wa_task_management_api,xui_webapp,ccd_case_disposer,sptribs_case_api' + doFirst { + def waManifest = file("$buildDir/cftlib/wa-task-management-api") + if (useLocalWaTaskManagementApi && waManifest.exists() && localWaM2Jar.exists()) { + def lines = waManifest.readLines() + if (lines.size() > 1) { + lines[1] = localWaM2Jar.absolutePath + waManifest.text = lines.join(System.lineSeparator()) + System.lineSeparator() + } + } + + def selectClass = project.findProperty('cftlibSelectClass') + if (name == 'cftlibTest' && selectClass) { + def libTestManifest = file("$buildDir/cftlib/libTest") + if (libTestManifest.exists()) { + def lines = libTestManifest.readLines() + if (!lines.isEmpty()) { + lines[0] = "org.junit.platform.console.ConsoleLauncher --select-class=${selectClass}" + libTestManifest.text = lines.join(System.lineSeparator()) + System.lineSeparator() + } + } + } + } } bootWithCCD { @@ -573,15 +651,13 @@ cftlibTest { environment 'CASE_DOCUMENT_AM_API_ATTACH_DOCUMENT_ENABLED', 'false' environment 'CASE_DATA_STORE_BASEURL', 'http://localhost:4452' environment 'ROLE_ASSIGNMENT_URL', 'http://localhost:4096' + environment 'TASK_MANAGEMENT_API_URL', 'http://localhost:8087' + environment 'TASK_MONITOR_API_URL', 'http://localhost:8087' + environment 'WA_S2S_AUTHORIZED_SERVICES', 'ccd,ccd_data,ccd_gw,ccd_ps,iac,wa_task_management_api,xui_webapp,wa_task_monitor,camunda_bpm,wa_workflow_api,wa_case_event_handler,ccd_case_disposer,civil_service,sscs,sptribs_case_api' environment 'CCD_S2S_AUTHORISED_SERVICES_CASE_USER_ROLES', 'sptribs_case_api' environment 'DATA_STORE_S2S_AUTHORISED_SERVICES', 'ccd_gw,fpl_case_service,ccd_data,ccd_ps,sptribs_frontend,xui_webapp,sptribs_case_api,ccd_case_document_am_api,am_role_assignment_service' } -// exclude the logback binding is coming in via cftlib -configurations.cftlibTestImplementation { - exclude group: 'ch.qos.logback', module: 'logback-classic' -} - tasks.register('installChromium', JavaExec) { // group = "Execution" // description = "Run the main class with JavaExecTask" @@ -592,11 +668,6 @@ tasks.register('installChromium', JavaExec) { tasks.cftlibTest.dependsOn(installChromium) -// exclude the logback binding is coming in via cftlib -configurations.testImplementation { - exclude group: 'ch.qos.logback', module: 'logback-classic' -} - tasks.named("processContractTestResources") { duplicatesStrategy = 'include' } diff --git a/charts/sptribs-case-api/values.preview.template.yaml b/charts/sptribs-case-api/values.preview.template.yaml index 0c83befbf6..ecf8ea3d5c 100644 --- a/charts/sptribs-case-api/values.preview.template.yaml +++ b/charts/sptribs-case-api/values.preview.template.yaml @@ -11,6 +11,9 @@ java: devmemoryLimits: 2Gi environment: PDF_API_URL: "http://rpe-pdf-service-aat.service.core-compute-aat.internal" + TASK_MONITOR_API_URL: ${TASK_MONITOR_API_URL} + TASK_MANAGEMENT_API_URL: ${TASK_MANAGEMENT_API_URL} + ROLE_ASSIGNMENT_API_URL: ${ROLE_ASSIGNMENT_API_URL} CASE_DATA_STORE_BASEURL: http://{{ .Release.Name }}-ccd-data-store-api CASE_DOCUMENT_AM_BASEURL: http://${SERVICE_NAME}-ccd-case-document-am-api BUNDLING_API_URL: https://em-ccdorc-${SERVICE_FQDN} diff --git a/charts/sptribs-case-api/values.wa.preview.template.yaml b/charts/sptribs-case-api/values.wa.preview.template.yaml index 9c3f6c80e3..3675e67d2c 100644 --- a/charts/sptribs-case-api/values.wa.preview.template.yaml +++ b/charts/sptribs-case-api/values.wa.preview.template.yaml @@ -8,7 +8,10 @@ java: key: connectionString environment: SPRING_JMS_SERVICEBUS_ENABLED: true - SPTRIBS_SERVICEBUS_SCHEDULER_ENABLED: true + SPTRIBS_SERVICEBUS_SCHEDULER_ENABLED: false + TASK_MONITOR_API_URL: ${TASK_MONITOR_API_URL} + TASK_MANAGEMENT_API_URL: ${TASK_MANAGEMENT_API_URL} + ROLE_ASSIGNMENT_API_URL: ${ROLE_ASSIGNMENT_API_URL} AZURE_SERVICE_BUS_TOPIC_NAME: ${SERVICE_NAME}-asb-ccd-case-events AZURE_SERVICE_BUS_SUBSCRIPTION_NAME: ${SERVICE_NAME}-asb-ccd-case-events @@ -72,9 +75,13 @@ wa: wa-task-management-api: java: ingressHost: wa-task-management-api-${SERVICE_FQDN} + image: 'hmctspublic.azurecr.io/wa/task-management-api:pr-1598' environment: ALLOWED_CASE_TYPES: wacasetype,criminalinjuriescompensation ALLOWED_JURISDICTIONS: wa,st_cic + WA_S2S_AUTHORIZED_SERVICES: ccd,ccd_data,ccd_gw,ccd_ps,iac,wa_task_management_api,xui_webapp,wa_task_monitor,camunda_bpm,wa_workflow_api,wa_case_event_handler,ccd_case_disposer,civil_service,sscs,sptribs_case_api + TASK_MANAGEMENT_EXCLUSIVE_CLIENTS: wa_task_management_api,wa_task_monitor,wa_case_event_handler,wa_workflow_api,nfdiv_case_api,sptribs_case_api + TASK_MANAGEMENT_PRIVILEGED_CLIENTS: wa_task_management_api,xui_webapp,ccd_case_disposer,sptribs_case_api wa-task-monitor: java: diff --git a/gradle/wa-publish-fix.init.gradle b/gradle/wa-publish-fix.init.gradle new file mode 100644 index 0000000000..290c8cf686 --- /dev/null +++ b/gradle/wa-publish-fix.init.gradle @@ -0,0 +1,9 @@ +allprojects { + afterEvaluate { p -> + if (p.tasks.findByName('sourcesJar') && p.tasks.findByName('openApiGenerate')) { + p.tasks.named('sourcesJar') { + dependsOn p.tasks.named('openApiGenerate') + } + } + } +} diff --git a/settings.gradle b/settings.gradle index bf14c20258..7ad2c09449 100644 --- a/settings.gradle +++ b/settings.gradle @@ -20,4 +20,3 @@ rootProject.name = 'sptribs-case-api' if (file(configGenerator).exists()) { includeBuild configGenerator }*/ - diff --git a/src/cftlib/java/uk/gov/hmcts/sptribs/cftlib/CftLibConfig.java b/src/cftlib/java/uk/gov/hmcts/sptribs/cftlib/CftLibConfig.java index 52eb690431..812658d0c1 100644 --- a/src/cftlib/java/uk/gov/hmcts/sptribs/cftlib/CftLibConfig.java +++ b/src/cftlib/java/uk/gov/hmcts/sptribs/cftlib/CftLibConfig.java @@ -30,11 +30,23 @@ public class CftLibConfig implements CFTLibConfigurer { @Override public void configure(CFTLib lib) throws Exception { - List roleList = List.of("caseworker", + List roleList = List.of( + "caseworker", "caseworker-st_cic", "caseworker-st_cic-caseworker", + "caseworker-st_cic-senior-caseworker", + "caseworker-st_cic-hearing-centre-admin", + "caseworker-st_cic-hearing-centre-team-leader", + "caseworker-st_cic-senior-judge", + "caseworker-st_cic-judge", + "caseworker-st_cic-respondent", + "caseworker-wa-task-configuration", + "caseworker-sptribs-systemupdate", + "caseworker-sptribs-superuser", + "citizen", "pui-case-manager", - "jrd-admin"); + "jrd-admin" + ); Map> users = Map.of( "TEST_CASE_WORKER_USER@mailinator.com", roleList, diff --git a/src/cftlibTest/java/uk/gov/hmcts/sptribs/cftlib/TaskManagementParityCftlibTest.java b/src/cftlibTest/java/uk/gov/hmcts/sptribs/cftlib/TaskManagementParityCftlibTest.java new file mode 100644 index 0000000000..37b65e764a --- /dev/null +++ b/src/cftlibTest/java/uk/gov/hmcts/sptribs/cftlib/TaskManagementParityCftlibTest.java @@ -0,0 +1,1101 @@ +package uk.gov.hmcts.sptribs.cftlib; + +import com.fasterxml.jackson.core.type.TypeReference; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.apache.http.client.methods.HttpPost; +import org.apache.http.client.methods.HttpRequestBase; +import org.apache.http.entity.ContentType; +import org.apache.http.entity.StringEntity; +import org.apache.http.impl.client.HttpClientBuilder; +import org.apache.http.util.EntityUtils; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; +import org.springframework.test.context.TestPropertySource; +import uk.gov.hmcts.reform.ccd.client.CoreCaseDataApi; +import uk.gov.hmcts.reform.ccd.client.model.StartEventResponse; +import uk.gov.hmcts.reform.idam.client.IdamClient; +import uk.gov.hmcts.rse.ccd.lib.test.CftlibTest; +import uk.gov.hmcts.sptribs.ciccase.model.CaseData; +import uk.gov.hmcts.sptribs.ciccase.model.State; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.time.Duration; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.awaitility.Awaitility.await; +import static org.junit.jupiter.params.provider.Arguments.arguments; + +@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) +@TestPropertySource(properties = { + "spring.jms.servicebus.enabled=false", + "spring.autoconfigure.exclude=com.azure.spring.cloud.autoconfigure.implementation.jms.ServiceBusJmsAutoConfiguration", + "spring.sql.init.mode=always", + "spring.sql.init.schema-locations=classpath:init-task-outbox.sql" +}) +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class TaskManagementParityCftlibTest extends CftlibTest { + + private static final String CASEWORKER_USER = "TEST_CASE_WORKER_USER@mailinator.com"; + private static final String BASE_URL = "http://localhost:4452"; + private static final String CASE_TYPE = "CriminalInjuriesCompensation"; + private static final String CREATE_CASE_EVENT = "caseworker-create-case"; + + private static final String ACCEPT_CREATE_CASE = + "application/vnd.uk.gov.hmcts.ccd-data-store-api.create-case.v2+json;charset=UTF-8"; + private static final String ACCEPT_CREATE_EVENT = + "application/vnd.uk.gov.hmcts.ccd-data-store-api.create-event.v2+json;charset=UTF-8"; + + private static final List REVIEW_TASKS_EXCLUDING_REVIEW_ORDER = Stream.of(TaskType.values()) + .filter(taskType -> taskType.name().startsWith("review") + && !taskType.name().startsWith("reviewSpecificAccess") + && taskType != TaskType.reviewOrder) + .toList(); + private static final List CREATE_DRAFT_ORDER_COMPLETABLE_TASKS = + Stream.concat(REVIEW_TASKS_EXCLUDING_REVIEW_ORDER.stream(), Stream.of(TaskType.createDueDate)).toList(); + private static final List CREATE_AND_SEND_ORDER_COMPLETABLE_TASKS = REVIEW_TASKS_EXCLUDING_REVIEW_ORDER; + private static final List SEND_ORDER_COMPLETABLE_TASKS = List.of( + TaskType.processCaseWithdrawalDirections, + TaskType.processCaseWithdrawalDirectionsListed, + TaskType.processRule27Decision, + TaskType.processRule27DecisionListed, + TaskType.processListingDirections, + TaskType.processListingDirectionsListed, + TaskType.processDirectionsReListedCase, + TaskType.processDirectionsReListedCaseWithin5Days, + TaskType.processSetAsideDirections, + TaskType.processCorrections, + TaskType.processDirectionsReturned, + TaskType.processPostponementDirections, + TaskType.processTimeExtensionDirectionsReturned, + TaskType.processReinstatementDecisionNotice, + TaskType.processOtherDirectionsReturned, + TaskType.processWrittenReasons, + TaskType.processStrikeOutDirectionsReturned, + TaskType.processStayDirections, + TaskType.processStayDirectionsListed, + TaskType.issueDueDate + ); + private static final List REFERRAL_COMPLETABLE_TASKS = + List.of(TaskType.followUpNoncomplianceOfDirections, TaskType.processFurtherEvidence); + private static final List REFERRAL_CANCELLABLE_TASKS = + TaskType.getTaskTypesFromProcessCategoryIdentifiers(List.of(ProcessCategoryIdentifiers.IssueCase)); + private static final List POSTPONE_HEARING_CANCELLABLE_TASKS = + TaskType.getTaskTypesFromProcessCategoryIdentifiers( + List.of(ProcessCategoryIdentifiers.HearingCompletion, ProcessCategoryIdentifiers.HearingBundle)); + private static final List CLOSE_CASE_CANCELLABLE_TASKS = List.of(TaskType.values()); + + private static final Map EVENT_FIXTURES = Map.ofEntries( + Map.entry("create-draft-order", "src/functionalTest/resources/wa/caseworker-create-draft-order-submit-data.json"), + Map.entry("create-and-send-order", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-create-and-send-order-upload-callback-request.json"), + Map.entry("caseworker-send-order", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-send-order-callback-request.json"), + Map.entry("create-hearing-summary", "src/functionalTest/resources/wa/caseworker-create-hearing-summary-submit-data.json"), + Map.entry("caseworker-cancel-hearing", "src/functionalTest/resources/wa/caseworker-cancel-hearing-submit-data.json"), + Map.entry("caseworker-postpone-hearing", "src/functionalTest/resources/wa/caseworker-postpone-hearing-submit-data.json"), + Map.entry("caseworker-close-the-case", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-close-case-about-to-submit.json"), + Map.entry("caseworker-issue-case", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-issue-case-about-to-submit.json"), + Map.entry("caseworker-issue-decision", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-issue-decision-callback-request.json"), + Map.entry("caseworker-issue-final-decision", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-issue-final-decision-callback-request.json"), + Map.entry("refer-to-judge", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-refer-to-judge-callback-request.json"), + Map.entry("refer-to-legal-officer", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-refer-to-legal-officer-callback-request.json"), + Map.entry("edit-case", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-edit-case-request.json"), + Map.entry("contact-parties", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-contact-parties-submitted.json"), + Map.entry("caseworker-document-management", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-document-management-about-to-submit.json"), + Map.entry("respondent-document-management", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-document-management-about-to-submit.json"), + Map.entry("caseworker-amend-document", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-document-management-amend-request.json"), + Map.entry("caseworker-amend-due-date", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-manage-order-due-date-callback-request.json"), + Map.entry("createBundle", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-create-bundle-about-to-submit.json"), + Map.entry("citizen-cic-submit-dss-application", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-citizen-cic-create-case-about-to-submit.json"), + Map.entry("citizen-cic-dss-update-case", + "src/functionalTest/resources/request/casedata/ccd-callback-casedata-dss-update-case-submission-about-to-submit.json") + ); + private static final Map REFERRAL_REASON_CODES = Map.ofEntries( + Map.entry("Corrections", "corrections"), + Map.entry("Listed case", "listedCase"), + Map.entry("Listed case (within 5 days)", "listedCaseWithin5Days"), + Map.entry("Listing directions", "listingDirections"), + Map.entry("New case", "newCase"), + Map.entry("Postponement request", "postponementRequest"), + Map.entry("Reinstatement request", "reinstatementRequest"), + Map.entry("Rule 27 request", "rule27Request"), + Map.entry("Set aside request", "setAsideRequest"), + Map.entry("Stay request", "stayRequest"), + Map.entry("Strike out request", "strikeOutRequest"), + Map.entry("Time extension request", "timeExtensionRequest"), + Map.entry("Withdrawal request", "withdrawalRequest"), + Map.entry("Written reasons request", "writtenReasonsRequest"), + Map.entry("Other", "other") + ); + + @Autowired + private NamedParameterJdbcTemplate db; + + @Autowired + private IdamClient idam; + + @Autowired + private CoreCaseDataApi ccdApi; + + @Autowired + private ObjectMapper mapper; + + @Autowired + private TaskManagementService taskManagementService; + + private final Map> fixtureCache = new HashMap<>(); + private Map createCaseSeedData; + + @BeforeAll + void setUpSeedData() { + createCaseSeedData = readJsonFile("src/main/resources/data/st_cic_test_case.json"); + } + + @Test + void caseworkerCaseBuilt_shouldCompleteVetAndInitiateIssueCaseToRespondent() { + runEventAndAssert( + "caseworker-case-built", + CASEWORKER_USER, + State.Submitted, + Map.of(), + List.of(TaskType.issueCaseToRespondent), + List.of(TaskType.vetNewCaseDocuments), + List.of(), + List.of(TaskType.vetNewCaseDocuments) + ); + } + + @Test + void caseworkerIssueCase_shouldCompleteIssueCaseTaskAndInitiateCreateDueDateTask() { + runEventAndAssert( + "caseworker-issue-case", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(TaskType.createDueDate), + List.of(TaskType.issueCaseToRespondent), + List.of(), + List.of(TaskType.issueCaseToRespondent) + ); + } + + @Test + void caseworkerIssueDecision_shouldCompleteIssueDecisionNoticeTask() { + runEventAndAssert( + "caseworker-issue-decision", + CASEWORKER_USER, + State.AwaitingOutcome, + Map.of(), + List.of(), + List.of(TaskType.issueDecisionNotice), + List.of(), + List.of(TaskType.issueDecisionNotice) + ); + } + + @Test + void caseworkerIssueFinalDecision_shouldCompleteIssueDecisionNoticeTask() { + runEventAndAssert( + "caseworker-issue-final-decision", + CASEWORKER_USER, + State.AwaitingOutcome, + Map.of(), + List.of(), + List.of(TaskType.issueDecisionNotice), + List.of(), + List.of(TaskType.issueDecisionNotice) + ); + } + + @Test + void caseworkerCreateHearingSummary_shouldCompleteHearingOutcomeAndInitiateIssueDecisionNotice() { + runEventAndAssert( + "create-hearing-summary", + CASEWORKER_USER, + State.AwaitingHearing, + Map.of(), + List.of(TaskType.issueDecisionNotice), + List.of(TaskType.completeHearingOutcome), + List.of(), + List.of(TaskType.completeHearingOutcome) + ); + } + + @Test + void caseworkerDocumentManagement_shouldCompleteFollowUpAndInitiateProcessFurtherEvidence() { + runEventAndAssert( + "caseworker-document-management", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(TaskType.processFurtherEvidence), + List.of(TaskType.followUpNoncomplianceOfDirections), + List.of(), + List.of(TaskType.followUpNoncomplianceOfDirections) + ); + } + + @Test + void respondentDocumentManagement_shouldInitiateProcessFurtherEvidence() { + runEventAndAssert( + "respondent-document-management", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(TaskType.processFurtherEvidence), + List.of(), + List.of(), + List.of() + ); + } + + @Test + void caseworkerDocumentManagementAmend_shouldCompleteProcessFurtherEvidence() { + runEventAndAssert( + "caseworker-amend-document", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(), + List.of(TaskType.processFurtherEvidence), + List.of(), + List.of(TaskType.processFurtherEvidence) + ); + } + + @Test + void caseworkerContactParties_shouldCompleteFollowUpAndProcessFurtherEvidence() { + runEventAndAssert( + "contact-parties", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(), + List.of(TaskType.followUpNoncomplianceOfDirections, TaskType.processFurtherEvidence), + List.of(), + List.of(TaskType.followUpNoncomplianceOfDirections, TaskType.processFurtherEvidence) + ); + } + + @Test + void caseworkerAmendDueDate_shouldCompleteFollowUpNoncomplianceTask() { + runEventAndAssert( + "caseworker-amend-due-date", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(), + List.of(TaskType.followUpNoncomplianceOfDirections), + List.of(), + List.of(TaskType.followUpNoncomplianceOfDirections) + ); + } + + @Test + void createBundle_shouldCompleteStitchCollateHearingBundleTask() { + runEventAndAssert( + "createBundle", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(), + List.of(TaskType.stitchCollateHearingBundle), + List.of(), + List.of(TaskType.stitchCollateHearingBundle) + ); + } + + @Test + void caseworkerCancelHearing_shouldCancelCompleteHearingOutcomeAndStitchBundleTasks() { + runEventAndAssert( + "caseworker-cancel-hearing", + CASEWORKER_USER, + State.AwaitingHearing, + Map.of(), + List.of(), + List.of(), + List.of(TaskType.completeHearingOutcome, TaskType.stitchCollateHearingBundle), + List.of(TaskType.completeHearingOutcome, TaskType.stitchCollateHearingBundle) + ); + } + + @Test + void caseworkerPostponeHearing_shouldCancelHearingCompletionAndBundleTasks() { + runEventAndAssert( + "caseworker-postpone-hearing", + CASEWORKER_USER, + State.AwaitingHearing, + Map.of(), + List.of(), + List.of(), + POSTPONE_HEARING_CANCELLABLE_TASKS, + POSTPONE_HEARING_CANCELLABLE_TASKS + ); + } + + @Test + void caseworkerCloseTheCase_shouldCancelAllKnownTaskTypes() { + runEventAndAssert( + "caseworker-close-the-case", + CASEWORKER_USER, + State.CaseManagement, + Map.of(), + List.of(), + List.of(), + CLOSE_CASE_CANCELLABLE_TASKS, + List.of() + ); + } + + @Test + void systemTriggerCompleteHearingOutcome_shouldInitiateCompleteHearingOutcomeTask() { + runEventAndAssert( + "system-trigger-complete-hearing-outcome", + CASEWORKER_USER, + State.AwaitingHearing, + Map.of(), + List.of(TaskType.completeHearingOutcome), + List.of(), + List.of(), + List.of() + ); + } + + @Test + void systemTriggerStitchCollateHearingBundle_shouldInitiateStitchCollateTask() { + runEventAndAssert( + "system-trigger-stitch-collate-hearing-bundle", + CASEWORKER_USER, + State.AwaitingHearing, + Map.of(), + List.of(TaskType.stitchCollateHearingBundle), + List.of(), + List.of(), + List.of() + ); + } + + @Test + void citizenSubmitCase_shouldInitiateRegisterNewCaseTask() { + runEventAndAssert( + "citizen-cic-submit-dss-application", + CASEWORKER_USER, + State.DSS_Draft, + Map.of(), + List.of(TaskType.registerNewCase), + List.of(), + List.of(), + List.of() + ); + } + + @Test + void citizenDssUpdateCase_shouldInitiateProcessFurtherEvidenceTask() { + runEventAndAssert( + "citizen-cic-dss-update-case", + CASEWORKER_USER, + State.DSS_Submitted, + Map.of(), + List.of(TaskType.processFurtherEvidence), + List.of(), + List.of(), + List.of() + ); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("caseworkerSendOrderScenarios") + void caseworkerSendOrder_shouldCompleteExpectedTasksAndInitiateExpectedTasks( + String scenario, + State preState, + List expectedInitiation + ) { + runEventAndAssert( + "caseworker-send-order", + CASEWORKER_USER, + preState, + Map.of(), + expectedInitiation, + SEND_ORDER_COMPLETABLE_TASKS, + List.of(), + List.of() + ); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("createAndSendOrderScenarios") + void createAndSendOrder_shouldCompleteExpectedTasksAndInitiateExpectedTasks( + String scenario, + State preState, + Map overlay, + List expectedInitiation + ) { + runEventAndAssert( + "create-and-send-order", + CASEWORKER_USER, + preState, + overlay, + expectedInitiation, + CREATE_AND_SEND_ORDER_COMPLETABLE_TASKS, + List.of(), + List.of() + ); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("editCaseScenarios") + void editCase_shouldCompleteExpectedTasksAndInitiateExpectedTasks( + String scenario, + State preState, + List expectedInitiation + ) { + runEventAndAssert( + "edit-case", + CASEWORKER_USER, + preState, + Map.of(), + expectedInitiation, + List.of(TaskType.registerNewCase, TaskType.processFurtherEvidence), + List.of(), + List.of(TaskType.registerNewCase, TaskType.processFurtherEvidence) + ); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("createDraftOrderScenarios") + void createDraftOrder_shouldCompleteExpectedTasksAndInitiateExpectedTasks( + String scenario, + State preState, + Map overlay, + List expectedInitiation + ) { + runEventAndAssert( + "create-draft-order", + CASEWORKER_USER, + preState, + overlay, + expectedInitiation, + CREATE_DRAFT_ORDER_COMPLETABLE_TASKS, + List.of(), + List.of() + ); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("referToJudgeScenarios") + void referToJudge_shouldCancelAndCompleteExpectedTasksAndInitiateExpectedJudgeTask( + String scenario, + State preState, + Map overlay, + List expectedInitiation + ) { + runEventAndAssert( + "refer-to-judge", + CASEWORKER_USER, + preState, + overlay, + expectedInitiation, + REFERRAL_COMPLETABLE_TASKS, + REFERRAL_CANCELLABLE_TASKS, + combineDistinct(REFERRAL_COMPLETABLE_TASKS, REFERRAL_CANCELLABLE_TASKS) + ); + } + + @ParameterizedTest(name = "{0}") + @MethodSource("referToLegalOfficerScenarios") + void referToLegalOfficer_shouldCancelAndCompleteExpectedTasksAndInitiateExpectedLoTask( + String scenario, + State preState, + Map overlay, + List expectedInitiation + ) { + runEventAndAssert( + "refer-to-legal-officer", + CASEWORKER_USER, + preState, + overlay, + expectedInitiation, + REFERRAL_COMPLETABLE_TASKS, + REFERRAL_CANCELLABLE_TASKS, + combineDistinct(REFERRAL_COMPLETABLE_TASKS, REFERRAL_CANCELLABLE_TASKS) + ); + } + + private Stream caseworkerSendOrderScenarios() { + return Stream.of( + arguments( + "caseworker-send-order from CaseManagement initiates followUpNoncomplianceOfDirections", + State.CaseManagement, + List.of(TaskType.followUpNoncomplianceOfDirections) + ), + arguments( + "caseworker-send-order from AwaitingHearing does not initiate new tasks", + State.AwaitingHearing, + List.of() + ) + ); + } + + private Stream createAndSendOrderScenarios() { + return Stream.of( + arguments( + "create-and-send-order with first due date in CaseManagement initiates followUpNoncomplianceOfDirections", + State.CaseManagement, + Map.of("cicCaseFirstOrderDueDate", "2026-04-02"), + List.of(TaskType.followUpNoncomplianceOfDirections) + ), + arguments( + "create-and-send-order with AdminActionRequired in CaseManagement initiates reviewOrder", + State.CaseManagement, + Map.of("cicCaseAdminActionRequired", List.of("AdminActionRequired")), + List.of(TaskType.reviewOrder) + ), + arguments( + "create-and-send-order with due date and AdminActionRequired in CaseManagement initiates both tasks", + State.CaseManagement, + Map.of( + "cicCaseAdminActionRequired", List.of("AdminActionRequired"), + "cicCaseFirstOrderDueDate", "2026-04-02" + ), + List.of(TaskType.followUpNoncomplianceOfDirections, TaskType.reviewOrder) + ), + arguments( + "create-and-send-order with AdminActionRequired in ReadyToList initiates reviewOrder", + State.ReadyToList, + Map.of("cicCaseAdminActionRequired", List.of("AdminActionRequired")), + List.of(TaskType.reviewOrder) + ), + arguments( + "create-and-send-order with AdminActionRequired in AwaitingHearing initiates reviewOrder", + State.AwaitingHearing, + Map.of("cicCaseAdminActionRequired", List.of("AdminActionRequired")), + List.of(TaskType.reviewOrder) + ) + ); + } + + private Stream editCaseScenarios() { + return Stream.of( + arguments( + "edit-case from Submitted initiates vetNewCaseDocuments", + State.Submitted, + List.of(TaskType.vetNewCaseDocuments) + ), + arguments( + "edit-case from CaseManagement does not initiate vet task", + State.CaseManagement, + List.of() + ) + ); + } + + private Stream createDraftOrderScenarios() { + return Stream.of( + arguments( + "create-draft-order CaseManagement with blank referral initiates issueDueDate", + State.CaseManagement, + referralOverlay(""), + List.of(TaskType.issueDueDate) + ), + arguments( + "create-draft-order AwaitingHearing withdrawal request initiates processCaseWithdrawalDirectionsListed", + State.AwaitingHearing, + referralOverlay("Withdrawal request"), + List.of(TaskType.processCaseWithdrawalDirectionsListed) + ), + arguments( + "create-draft-order CaseManagement listing directions initiates processListingDirections", + State.CaseManagement, + referralOverlay("Listing directions"), + List.of(TaskType.processListingDirections) + ), + arguments( + "create-draft-order CaseClosed set aside request initiates processSetAsideDirections", + State.CaseClosed, + referralOverlay("Set aside request"), + List.of(TaskType.processSetAsideDirections) + ), + arguments( + "create-draft-order CaseManagement stay request initiates processStayDirections", + State.CaseManagement, + referralOverlay("Stay request"), + List.of(TaskType.processStayDirections) + ) + ); + } + + private Stream referToJudgeScenarios() { + return Stream.of( + arguments("refer-to-judge new case in CaseManagement initiates reviewNewCaseAndProvideDirectionsJudge", + State.CaseManagement, referralOverlay("New case"), List.of(TaskType.reviewNewCaseAndProvideDirectionsJudge)), + arguments("refer-to-judge stay request in AwaitingHearing initiates reviewStayRequestCaseListedJudge", + State.AwaitingHearing, referralOverlay("Stay request"), List.of(TaskType.reviewStayRequestCaseListedJudge)), + arguments("refer-to-judge listing directions in ReadyToList initiates reviewListingDirectionsCaseListedJudge", + State.ReadyToList, referralOverlay("Listing directions"), + List.of(TaskType.reviewListingDirectionsCaseListedJudge)), + arguments("refer-to-judge corrections in CaseClosed initiates reviewCorrectionsRequest", + State.CaseClosed, referralOverlay("Corrections"), List.of(TaskType.reviewCorrectionsRequest)), + arguments("refer-to-judge other request in CaseManagement initiates reviewOtherRequestJudge", + State.CaseManagement, referralOverlay("Other"), List.of(TaskType.reviewOtherRequestJudge)) + ); + } + + private Stream referToLegalOfficerScenarios() { + return Stream.of( + arguments("refer-to-legal-officer new case in CaseManagement initiates reviewNewCaseAndProvideDirectionsLO", + State.CaseManagement, referralOverlay("New case"), List.of(TaskType.reviewNewCaseAndProvideDirectionsLO)), + arguments("refer-to-legal-officer stay request in AwaitingHearing initiates reviewStayRequestCaseListedLO", + State.AwaitingHearing, referralOverlay("Stay request"), List.of(TaskType.reviewStayRequestCaseListedLO)), + arguments("refer-to-legal-officer listing directions in ReadyToList initiates reviewListingDirectionsCaseListedLO", + State.ReadyToList, referralOverlay("Listing directions"), + List.of(TaskType.reviewListingDirectionsCaseListedLO)), + arguments("refer-to-legal-officer reinstatement request in CaseClosed initiates reviewReinstatementRequestLO", + State.CaseClosed, referralOverlay("Reinstatement request"), List.of(TaskType.reviewReinstatementRequestLO)), + arguments("refer-to-legal-officer other request in CaseManagement initiates reviewOtherRequestLO", + State.CaseManagement, referralOverlay("Other"), List.of(TaskType.reviewOtherRequestLO)) + ); + } + + private void runEventAndAssert( + String eventId, + String user, + State preState, + Map scenarioOverlay, + List expectedInitiation, + List expectedCompletion, + List expectedCancellation, + List tasksToSeedForTermination + ) { + long caseId = createCase(); + clearTaskOutbox(caseId); + + Map overlay = buildEventOverlay(eventId, scenarioOverlay); + updateCaseStateAndData(caseId, preState, overlay); + List tasksToSeed = tasksToSeedForTermination.isEmpty() + ? combineDistinct(expectedCompletion, expectedCancellation) + : tasksToSeedForTermination; + seedTasksForTermination(caseId, tasksToSeed); + + submitEvent(caseId, user, eventId, overlay); + + assertInitiationOutbox(caseId, expectedInitiation, eventId); + assertTerminationOutbox(caseId, "complete", expectedCompletion, eventId); + assertTerminationOutbox(caseId, "cancel", expectedCancellation, eventId); + } + + private long createCase() { + StartEventResponse start = ccdApi.startCase( + getAuthorisation(CASEWORKER_USER), + getServiceAuth(), + CASE_TYPE, + CREATE_CASE_EVENT + ); + + Map submissionData = new HashMap<>(toMap(start.getCaseDetails().getData())); + deepMerge(submissionData, cloneMap(createCaseSeedData)); + + Map body = new HashMap<>(); + body.put("data", submissionData); + body.put("event", Map.of("id", CREATE_CASE_EVENT, "summary", "", "description", "")); + body.put("event_token", start.getToken()); + body.put("ignore_warning", false); + + HttpPost request = buildRequest( + CASEWORKER_USER, + BASE_URL + "/data/case-types/" + CASE_TYPE + "/cases?ignore-warning=false" + ); + withCcdAccept(request, ACCEPT_CREATE_CASE); + + try { + request.setEntity(new StringEntity(mapper.writeValueAsString(body), ContentType.APPLICATION_JSON)); + var response = HttpClientBuilder.create().build().execute(request); + try { + int status = response.getStatusLine().getStatusCode(); + String responseBody = EntityUtils.toString(response.getEntity()); + assertThat(status).as("Case creation must return 201. body=%s", responseBody).isEqualTo(201); + Map payload = mapper.readValue(responseBody, new TypeReference<>() { + }); + return Long.parseLong(String.valueOf(payload.get("id"))); + } finally { + response.close(); + } + } catch (IOException ex) { + throw new IllegalStateException("Unable to create CCD case", ex); + } + } + + private void submitEvent(long caseId, String user, String eventId, Map overlay) { + StartEventResponse start = ccdApi.startEvent( + getAuthorisation(user), + getServiceAuth(), + String.valueOf(caseId), + eventId + ); + + Map submissionData = new HashMap<>(toMap(start.getCaseDetails().getData())); + deepMerge(submissionData, cloneMap(overlay)); + + Map body = new HashMap<>(); + body.put("data", submissionData); + body.put("event", Map.of("id", eventId, "summary", "task-management-functional", "description", "task-management-functional")); + body.put("event_token", start.getToken()); + body.put("ignore_warning", false); + + HttpPost request = buildRequest(user, BASE_URL + "/cases/" + caseId + "/events"); + withCcdAccept(request, ACCEPT_CREATE_EVENT); + + try { + request.setEntity(new StringEntity(mapper.writeValueAsString(body), ContentType.APPLICATION_JSON)); + var response = HttpClientBuilder.create().build().execute(request); + try { + int status = response.getStatusLine().getStatusCode(); + String responseBody = EntityUtils.toString(response.getEntity()); + assertThat(status).as("Event submit must return 201 for %s. body=%s", eventId, responseBody).isEqualTo(201); + } finally { + response.close(); + } + } catch (IOException ex) { + throw new IllegalStateException("Unable to submit event " + eventId, ex); + } + } + + private void updateCaseStateAndData(long caseId, State state, Map overlay) { + Map caseData = loadCaseData(caseId); + deepMerge(caseData, cloneMap(overlay)); + caseData.put("caseStatus", state.name()); + + try { + db.update( + "UPDATE ccd.case_data SET state = :state, data = CAST(:data AS jsonb) WHERE reference = :ref", + Map.of( + "state", state.name(), + "data", mapper.writeValueAsString(caseData), + "ref", caseId + ) + ); + } catch (IOException ex) { + throw new IllegalStateException("Unable to update case data for " + caseId, ex); + } + } + + private Map loadCaseData(long caseId) { + String json = db.queryForObject( + "SELECT data::text FROM ccd.case_data WHERE reference = :ref", + Map.of("ref", caseId), + String.class + ); + return parseJsonObject(json); + } + + private void clearTaskOutbox(long caseId) { + db.update("DELETE FROM ccd.task_outbox WHERE case_id = :caseId", Map.of("caseId", String.valueOf(caseId))); + } + + private void seedTasksForTermination(long caseId, List taskTypes) { + List distinctTaskTypes = taskTypes.stream().distinct().toList(); + if (distinctTaskTypes.isEmpty()) { + return; + } + + CaseData caseData = mapper.convertValue(loadCaseData(caseId), CaseData.class); + taskManagementService.enqueueInitiationTasks(distinctTaskTypes, caseData, caseId); + + await().atMost(Duration.ofSeconds(45)).untilAsserted(() -> { + List> rows = db.queryForList( + "SELECT status, last_response_code FROM ccd.task_outbox " + + "WHERE case_id = :caseId AND action = :action::ccd.task_action", + Map.of("caseId", String.valueOf(caseId), "action", "initiate") + ); + assertThat(rows).hasSize(distinctTaskTypes.size()); + rows.forEach(this::assertProcessedRow); + }); + + clearTaskOutbox(caseId); + } + + private void assertInitiationOutbox(long caseId, List expectedTaskTypes, String eventId) { + List expectedTypes = expectedTaskTypes.stream().map(Enum::name).distinct().toList(); + if (expectedTypes.isEmpty()) { + assertNoTaskOutboxAction(caseId, "initiate"); + return; + } + + await().atMost(Duration.ofSeconds(45)).untilAsserted(() -> { + List> rows = db.queryForList( + "SELECT status, last_response_code, payload->'task'->>'type' AS task_type " + + "FROM ccd.task_outbox WHERE case_id = :caseId AND action = :action::ccd.task_action", + Map.of("caseId", String.valueOf(caseId), "action", "initiate") + ); + assertThat(rows).hasSize(expectedTypes.size()); + assertThat(rows.stream().map(row -> String.valueOf(row.get("task_type"))).toList()) + .as("Initiation outbox mismatch for event %s", eventId) + .containsExactlyInAnyOrderElementsOf(expectedTypes); + rows.forEach(this::assertProcessedRow); + }); + } + + private void assertTerminationOutbox(long caseId, String action, List expectedTaskTypes, String eventId) { + List expectedTypes = expectedTaskTypes.stream().map(Enum::name).distinct().toList(); + if (expectedTypes.isEmpty()) { + assertNoTaskOutboxAction(caseId, action); + return; + } + + await().atMost(Duration.ofSeconds(45)).untilAsserted(() -> { + Map row = db.queryForMap( + "SELECT status, last_response_code, " + + "COALESCE(payload->'task_types', payload->'task_type', payload->'taskType')::text AS task_types " + + "FROM ccd.task_outbox WHERE case_id = :caseId AND action = :action::ccd.task_action " + + "ORDER BY id DESC LIMIT 1", + Map.of("caseId", String.valueOf(caseId), "action", action.toLowerCase(Locale.ROOT)) + ); + assertProcessedRow(row); + List actualTypes = parseJsonArray(row.get("task_types")); + assertThat(new LinkedHashSet<>(actualTypes)) + .as("Termination outbox mismatch for event %s action %s", eventId, action) + .containsExactlyInAnyOrderElementsOf(new LinkedHashSet<>(expectedTypes)); + }); + } + + private void assertNoTaskOutboxAction(long caseId, String action) { + await().atMost(Duration.ofSeconds(20)).untilAsserted(() -> { + Integer count = db.queryForObject( + "SELECT count(*) FROM ccd.task_outbox WHERE case_id = :caseId AND action = :action::ccd.task_action", + Map.of("caseId", String.valueOf(caseId), "action", action.toLowerCase(Locale.ROOT)), + Integer.class + ); + assertThat(count).isEqualTo(0); + }); + } + + private void assertProcessedRow(Map row) { + assertThat(row.get("status")).isEqualTo("PROCESSED"); + Object responseCode = row.get("last_response_code"); + assertThat(responseCode).isNotNull(); + assertThat(((Number) responseCode).intValue()).isIn(200, 201, 204); + } + + private Map buildEventOverlay(String eventId, Map scenarioOverlay) { + Map overlay = cloneMap(loadFixtureForEvent(eventId)); + deepMerge(overlay, cloneMap(scenarioOverlay)); + applyEventDefaults(eventId, overlay); + return overlay; + } + + private Map loadFixtureForEvent(String eventId) { + String path = EVENT_FIXTURES.get(eventId); + if (path == null) { + return Collections.emptyMap(); + } + return fixtureCache.computeIfAbsent(path, this::readJsonFile); + } + + private void applyEventDefaults(String eventId, Map overlay) { + if ("create-draft-order".equals(eventId)) { + overlay.putIfAbsent("orderContentOrderTemplate", "CIC3_Rule_27"); + overlay.putIfAbsent("orderContentMainContent", "Order Main Content"); + overlay.putIfAbsent("orderContentOrderSignature", "Order Signatory"); + overlay.putIfAbsent("cicCaseOrderTemplateIssued", sampleDocument("DRAFT :Order--[Subject Name]--26-04-2024 10:09:12.pdf")); + } + + if ("create-and-send-order".equals(eventId)) { + overlay.putIfAbsent("cicCaseOrderIssuingType", "UploadOrder"); + overlay.putIfAbsent("cicCaseAdminActionRequired", null); + overlay.putIfAbsent("cicCaseFirstOrderDueDate", null); + overlay.putIfAbsent("cicCaseOrderDueDates", List.of()); + Object firstDueDate = overlay.get("cicCaseFirstOrderDueDate"); + if (firstDueDate instanceof String dueDate && !dueDate.isBlank()) { + overlay.put( + "cicCaseOrderDueDates", + List.of(Map.of("id", "1", "value", Map.of("dueDate", dueDate))) + ); + } + } + + if ("contact-parties".equals(eventId)) { + overlay.remove("contactPartiesDocumentsDocumentList"); + overlay.put( + "cicCaseApplicantDocumentsUploaded", + List.of( + Map.of( + "id", "1", + "value", Map.of( + "documentCategory", "ApplicationForm", + "documentEmailContent", "Party message", + "documentLink", sampleDocument("contact-parties.pdf") + ) + ) + ) + ); + } + + if ("citizen-cic-submit-dss-application".equals(eventId)) { + overlay.putIfAbsent("dssCaseDataSubjectFullName", "DSS Subject"); + overlay.putIfAbsent("dssCaseDataSubjectDateOfBirth", "1990-01-01"); + overlay.putIfAbsent("dssCaseDataSubjectEmailAddress", "subject@mailinator.com"); + overlay.putIfAbsent("dssCaseDataSubjectContactNumber", "07000000000"); + overlay.putIfAbsent("dssCaseDataSubjectAgreeContact", "Yes"); + overlay.putIfAbsent("dssCaseDataRepresentation", "No"); + overlay.putIfAbsent("dssCaseDataRepresentationQualified", "No"); + } + + if ("citizen-cic-dss-update-case".equals(eventId)) { + overlay.putIfAbsent("dssCaseDataAdditionalInformation", "Additional info"); + overlay.putIfAbsent("dssCaseDataOtherInfoDocuments", List.of()); + } + + if ("caseworker-issue-decision".equals(eventId)) { + Object draftDocument = overlay.get("caseIssueDecisionIssueDecisionDraft"); + if (draftDocument instanceof Map map && map.isEmpty()) { + overlay.remove("caseIssueDecisionIssueDecisionDraft"); + } + } + + if ("refer-to-judge".equals(eventId)) { + applyReferralReasonCode(overlay, "referToJudgeReferralReason"); + } + + if ("refer-to-legal-officer".equals(eventId)) { + applyReferralReasonCode(overlay, "referToLegalOfficerReferralReason"); + } + } + + private void applyReferralReasonCode(Map overlay, String referralReasonField) { + Object referralLabel = overlay.get("cicCaseReferralTypeForWA"); + if (referralLabel == null) { + return; + } + + String reasonCode = REFERRAL_REASON_CODES.get(String.valueOf(referralLabel)); + if (reasonCode != null) { + overlay.put(referralReasonField, reasonCode); + } + } + + private Map sampleDocument(String filename) { + String base = "http://localhost/documents/11111111-1111-1111-1111-111111111111"; + return Map.of( + "document_url", base, + "document_binary_url", base + "/binary", + "document_filename", filename, + "category_id", "TD" + ); + } + + private String getAuthorisation(String user) { + return idam.getAccessToken(user, ""); + } + + private String getServiceAuth() { + return cftlib().generateDummyS2SToken("ccd_gw"); + } + + private HttpPost buildRequest(String user, String url) { + HttpPost request = new HttpPost(url); + request.addHeader("Content-Type", "application/json"); + request.addHeader("ServiceAuthorization", getServiceAuth()); + request.addHeader("Authorization", getAuthorisation(user)); + return request; + } + + private void withCcdAccept(HttpRequestBase request, String accept) { + request.addHeader("experimental", "true"); + request.addHeader("Accept", accept); + } + + @SuppressWarnings("unchecked") + private void deepMerge(Map target, Map updates) { + for (Map.Entry entry : updates.entrySet()) { + Object existing = target.get(entry.getKey()); + Object update = entry.getValue(); + if (existing instanceof Map existingMap && update instanceof Map updateMap) { + deepMerge((Map) existingMap, (Map) updateMap); + } else { + target.put(entry.getKey(), update); + } + } + } + + private Map readJsonFile(String filePath) { + try { + return parseJsonObject(Files.readString(Path.of(filePath))); + } catch (IOException ex) { + throw new IllegalStateException("Unable to read JSON file: " + filePath, ex); + } + } + + private Map parseJsonObject(String json) { + try { + return mapper.readValue(json, new TypeReference<>() { + }); + } catch (IOException ex) { + throw new IllegalStateException("Unable to parse JSON object", ex); + } + } + + private List parseJsonArray(Object jsonValue) { + if (jsonValue == null) { + return List.of(); + } + try { + return mapper.readValue(String.valueOf(jsonValue), new TypeReference<>() { + }); + } catch (IOException ex) { + throw new IllegalStateException("Unable to parse JSON array: " + jsonValue, ex); + } + } + + private Map cloneMap(Map map) { + return mapper.convertValue(map, new TypeReference<>() { + }); + } + + @SuppressWarnings("unchecked") + private Map toMap(Object data) { + return mapper.convertValue(data, new TypeReference<>() { + }); + } + + private Map referralOverlay(String referralType) { + return Map.of("cicCaseReferralTypeForWA", referralType); + } + + private List combineDistinct(List first, List second) { + LinkedHashSet result = new LinkedHashSet<>(first); + result.addAll(second); + return List.copyOf(result); + } +} diff --git a/src/cftlibTest/resources/init-task-outbox.sql b/src/cftlibTest/resources/init-task-outbox.sql new file mode 100644 index 0000000000..5bb1f4713b --- /dev/null +++ b/src/cftlibTest/resources/init-task-outbox.sql @@ -0,0 +1,25 @@ +CREATE SCHEMA IF NOT EXISTS ccd; + +DROP TABLE IF EXISTS ccd.task_outbox; +DROP TYPE IF EXISTS ccd.task_action; + +CREATE TYPE ccd.task_action AS ENUM ('cancel', 'complete', 'initiate', 'reconfigure'); + +CREATE TABLE ccd.task_outbox ( + id bigserial primary key, + case_id text not null, + case_type_id text not null, + payload jsonb not null, + action ccd.task_action not null, + status text not null default 'NEW', + attempt_count integer not null default 0, + created timestamp not null default now(), + updated timestamp not null default now(), + processed timestamp, + next_attempt_at timestamp, + last_response_code integer, + last_error text +); + +CREATE INDEX idx_task_outbox_status_created ON ccd.task_outbox(status, created); +CREATE INDEX idx_task_outbox_status_next_attempt ON ccd.task_outbox(status, next_attempt_at); diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/caseworker/RespondentContactPartiesFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/caseworker/RespondentContactPartiesFT.java index 6ab9893310..2b94354774 100644 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/caseworker/RespondentContactPartiesFT.java +++ b/src/functionalTest/java/uk/gov/hmcts/sptribs/caseworker/RespondentContactPartiesFT.java @@ -3,17 +3,12 @@ import io.restassured.response.Response; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.StringUtils; -import org.apache.commons.lang3.Strings; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.sptribs.cdam.model.Document; -import uk.gov.hmcts.sptribs.cdam.model.UploadResponse; import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; import java.util.List; import java.util.Map; -import java.util.Optional; -import java.util.UUID; import static net.javacrumbs.jsonunit.assertj.JsonAssertions.assertThatJson; import static net.javacrumbs.jsonunit.assertj.JsonAssertions.json; @@ -117,11 +112,7 @@ public void shouldReturnErrorWhenSubjectSelectedAndCaseIsMinorOrFatalInMidEventC public void shouldNotReturnAnyErrorsInSelectDocumentMidEventCallback() throws Exception { final Map caseData = caseData(CONTACT_PARTIES_SELECT_DOCUMENT_MID_EVENT_REQUEST); - String documentId = "a17fa26b-6e91-48ba-841e-8ab75c772463"; - - UploadResponse uploadResponse = uploadTestDocumentIfMissing(documentId, DRAFT_ORDER_FILE); - String resolvedDocumentId = resolveDocumentId(documentId, uploadResponse); - updateDocumentSelectionWithDocumentId(caseData, resolvedDocumentId); + removeDocumentLinksFromSelection(caseData); final Response response = triggerCallback( caseData, @@ -140,11 +131,7 @@ public void shouldNotReturnAnyErrorsInSelectDocumentMidEventCallback() throws Ex public void shouldReturnAnErrorIfMoreThan10DocumentsUploadedInSelectDocumentMidEventCallback() throws Exception { final Map caseData = caseData(CONTACT_PARTIES_SELECT_DOCUMENT_TOO_MANY_DOCUMENTS_MID_EVENT_REQUEST); - String documentId = "a17fa26b-6e91-48ba-841e-8ab75c772463"; - - UploadResponse docUploadResponse = uploadTestDocumentIfMissing(documentId, DRAFT_ORDER_FILE); - String resolvedDocumentId = resolveDocumentId(documentId, docUploadResponse); - updateDocumentSelectionWithDocumentId(caseData, resolvedDocumentId); + removeDocumentLinksFromSelection(caseData); final Response response = triggerCallback( caseData, @@ -207,54 +194,9 @@ public void shouldReturnErrorWhenEmailNotificationsNotSentInSubmittedEvent() thr .isEqualTo("# Contact Parties notification failed \\n## Please resend the notification"); } - private String resolveDocumentId(String fallbackDocumentId, UploadResponse uploadResponse) { - if (uploadResponse == null - || uploadResponse.getDocuments() == null - || uploadResponse.getDocuments().isEmpty()) { - return fallbackDocumentId; - } - - Document uploadedDocument = uploadResponse.getDocuments().getFirst(); - if (uploadedDocument == null || uploadedDocument.links == null) { - return fallbackDocumentId; - } - - String documentHref = Optional.ofNullable(uploadedDocument.links) - .map(links -> { - if (links.self != null && StringUtils.isNotBlank(links.self.href)) { - return links.self.href; - } - if (links.binary != null && StringUtils.isNotBlank(links.binary.href)) { - return links.binary.href; - } - return null; - }) - .orElse(null); - - if (StringUtils.isBlank(documentHref)) { - return fallbackDocumentId; - } - - if (Strings.CS.endsWith(documentHref, "/binary")) { - documentHref = StringUtils.substringBeforeLast(documentHref, "/"); - } - - String extractedDocumentId = StringUtils.substringAfterLast(documentHref, "/"); - return isValidUuid(extractedDocumentId) ? extractedDocumentId : fallbackDocumentId; - } - - private boolean isValidUuid(String value) { - try { - UUID.fromString(value); - return true; - } catch (IllegalArgumentException ex) { - return false; - } - } - @SuppressWarnings("unchecked") - private void updateDocumentSelectionWithDocumentId(Map caseData, String documentId) { - if (caseData == null || StringUtils.isBlank(documentId)) { + private void removeDocumentLinksFromSelection(Map caseData) { + if (caseData == null) { return; } @@ -263,11 +205,11 @@ private void updateDocumentSelectionWithDocumentId(Map caseData, return; } - replaceDocumentId((List>) documentList.get("value"), documentId); - replaceDocumentId((List>) documentList.get("list_items"), documentId); + sanitizeSelectionLabels((List>) documentList.get("value")); + sanitizeSelectionLabels((List>) documentList.get("list_items")); } - private void replaceDocumentId(List> elements, String documentId) { + private void sanitizeSelectionLabels(List> elements) { if (elements == null) { return; } @@ -275,10 +217,7 @@ private void replaceDocumentId(List> elements, String docume for (Map element : elements) { Object labelObj = element.get("label"); if (labelObj instanceof String label) { - String updatedLabel = label - .replace("/null/", "/" + documentId + "/") - .replace("/null)", "/" + documentId + ")"); - element.put("label", updatedLabel); + element.put("label", StringUtils.substringBefore(label, "(").trim()); } } } diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/testutil/TaskManagementService.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/testutil/TaskManagementService.java deleted file mode 100644 index 3395a56d5b..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/testutil/TaskManagementService.java +++ /dev/null @@ -1,120 +0,0 @@ -package uk.gov.hmcts.sptribs.testutil; - -import io.restassured.response.Response; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Value; -import org.springframework.http.HttpStatus; -import org.springframework.http.MediaType; -import org.springframework.stereotype.Service; - -import java.util.List; -import java.util.Map; -import java.util.Set; - -import static io.restassured.RestAssured.given; -import static java.util.Collections.singletonList; -import static org.hamcrest.CoreMatchers.is; -import static org.springframework.http.HttpHeaders.AUTHORIZATION; -import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; -import static uk.gov.hmcts.sptribs.common.config.ControllerConstants.SERVICE_AUTHORIZATION; - -@Service -public class TaskManagementService { - - @Autowired - private TaskMonitorService taskMonitorService; - - @Autowired - private IdamTokenGenerator idamTokenGenerator; - - @Autowired - private ServiceAuthenticationGenerator serviceAuthenticationGenerator; - - @Value("${wa_task_management_api.url}") - private String taskManagementUrl; - - public Response search(String caseId, - List expectedTaskList, - int expectedTasks, - int expectedStatus) throws InterruptedException { - - //Also trigger (CRON) Jobs programmatically - taskMonitorService.triggerInitiationJob(); - taskMonitorService.triggerTerminationJob(); - taskMonitorService.triggerReconfigurationJob(); - - // Wait 80 seconds to allow time for task to be created in database - Thread.sleep(80000); - - Map searchParameter = Map.of( - "key", "caseId", - "operator", "IN", - "values", singletonList(caseId) - ); - - Map searchParameter2 = Map.of( - "key", "task_type", - "operator", "IN", - "values", expectedTaskList - ); - - Map>> requestBody = Map.of("search_parameters", Set.of(searchParameter, searchParameter2)); - Response result = given() - .header(SERVICE_AUTHORIZATION, serviceAuthenticationGenerator.generateTaskManagementToken()) - .header(AUTHORIZATION, idamTokenGenerator.generateIdamTokenForWASeniorCaseworker()) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .body(requestBody) - .when() - .post(taskManagementUrl + "/task/extended-search"); - - result.then().assertThat() - .statusCode(expectedStatus) - .contentType(APPLICATION_JSON_VALUE) - .body("tasks.size()", is(expectedTasks)); - - return result; - } - - public Response retrieveTaskRolePermissions(String taskId, - int expectedNumberOfRoles, - int expectedStatus) { - - Response result = given() - .header(SERVICE_AUTHORIZATION, serviceAuthenticationGenerator.generateTaskManagementToken()) - .header(AUTHORIZATION, idamTokenGenerator.generateIdamTokenForWASeniorCaseworker()) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .when() - .get(taskManagementUrl + "/task/" + taskId + "/roles"); - - result.then().assertThat() - .statusCode(expectedStatus) - .contentType(APPLICATION_JSON_VALUE) - .body("roles.size()", is(expectedNumberOfRoles)); - - return result; - } - - public void assignTask(String taskId) { - Response result = given() - .header(SERVICE_AUTHORIZATION, serviceAuthenticationGenerator.generateTaskManagementToken()) - .header(AUTHORIZATION, idamTokenGenerator.generateIdamTokenForWARegionalHearingCentreTeamLead()) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .when() - .post(taskManagementUrl + "/task/" + taskId + "/claim"); - - result.then().assertThat() - .statusCode(HttpStatus.NO_CONTENT.value()); - } - - public void completeTask(String taskId) { - Response result = given() - .header(SERVICE_AUTHORIZATION, serviceAuthenticationGenerator.generateTaskManagementToken()) - .header(AUTHORIZATION, idamTokenGenerator.generateIdamTokenForWARegionalHearingCentreTeamLead()) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .when() - .post(taskManagementUrl + "/task/" + taskId + "/complete"); - - result.then().assertThat() - .statusCode(HttpStatus.NO_CONTENT.value()); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/testutil/TaskMonitorService.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/testutil/TaskMonitorService.java deleted file mode 100644 index 2266f96063..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/testutil/TaskMonitorService.java +++ /dev/null @@ -1,71 +0,0 @@ -package uk.gov.hmcts.sptribs.testutil; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Value; -import org.springframework.http.MediaType; -import org.springframework.stereotype.Service; - -import java.util.Map; - -import static io.restassured.RestAssured.given; -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.awaitility.Awaitility.await; -import static org.springframework.http.HttpHeaders.AUTHORIZATION; -import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; -import static uk.gov.hmcts.sptribs.common.config.ControllerConstants.SERVICE_AUTHORIZATION; - -@Service -@Slf4j -public class TaskMonitorService { - - @Autowired - private IdamTokenGenerator idamTokenGenerator; - - @Autowired - private ServiceAuthenticationGenerator serviceAuthenticationGenerator; - - @Value("${wa_task_monitor_api.url}") - private String taskMonitorUrl; - - public static final int DEFAULT_TIMEOUT_SECONDS = 300; - public static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - public void triggerInitiationJob() { - Map> requestBody = Map.of("job_details", Map.of("name", "INITIATION")); - initiateJob(requestBody); - } - - public void triggerTerminationJob() { - Map> requestBody = Map.of("job_details", Map.of("name", "TERMINATION")); - initiateJob(requestBody); - } - - public void triggerReconfigurationJob() { - Map> requestBody = Map.of("job_details", Map.of("name", "RECONFIGURATION")); - initiateJob(requestBody); - } - - private void initiateJob(Map> requestBody) { - await() - .ignoreException(AssertionError.class) - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - Response result = given() - .header(SERVICE_AUTHORIZATION, serviceAuthenticationGenerator.generateTaskManagementToken()) - .header(AUTHORIZATION, idamTokenGenerator.generateIdamTokenForSystemUser()) - .contentType(MediaType.APPLICATION_JSON_VALUE) - .body(requestBody) - .when() - .post(taskMonitorUrl + "/monitor/tasks/jobs"); - - result.then().assertThat() - .statusCode(200) - .contentType(APPLICATION_JSON_VALUE); - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WACompleteHearingOutcomeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WACompleteHearingOutcomeFT.java deleted file mode 100644 index c638f0db8d..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WACompleteHearingOutcomeFT.java +++ /dev/null @@ -1,255 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.systemupdate.event.SystemTriggerCompleteHearingOutcome.SYSTEM_TRIGGER_COMPLETE_HEARING_OUTCOME; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CANCEL_HEARING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_POSTPONE_HEARING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; - -@SpringBootTest -@Slf4j -public class WACompleteHearingOutcomeFT extends FunctionalTestSuite { - - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "completeHearingOutcome"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - private static final String CASEWORKER_CANCEL_HEARING_DATA = "classpath:wa/caseworker-cancel-hearing-submit-data.json"; - private static final String CASEWORKER_POSTPONE_HEARING_DATA = "classpath:wa/caseworker-postpone-hearing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateCompleteHearingOutcomeTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - ccdCaseCreator.createInitialStartEventAndSubmitSystemEvent( - SYSTEM_TRIGGER_COMPLETE_HEARING_OUTCOME, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCancelCompleteHearingOutcomeTaskWithCaseworkerPostponeHearing() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - ccdCaseCreator.createInitialStartEventAndSubmitSystemEvent( - SYSTEM_TRIGGER_COMPLETE_HEARING_OUTCOME, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - caseData.putAll(caseData(CASEWORKER_POSTPONE_HEARING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_POSTPONE_HEARING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCancelCompleteHearingOutcomeTaskWithCaseworkerCancelHearing() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - ccdCaseCreator.createInitialStartEventAndSubmitSystemEvent( - SYSTEM_TRIGGER_COMPLETE_HEARING_OUTCOME, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - caseData.putAll(caseData(CASEWORKER_CANCEL_HEARING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CANCEL_HEARING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAFollowUpNoncomplianceOfDirectionsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAFollowUpNoncomplianceOfDirectionsFT.java deleted file mode 100644 index 1205f7d2b1..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAFollowUpNoncomplianceOfDirectionsFT.java +++ /dev/null @@ -1,104 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_SEND_ORDER; - -@SpringBootTest -@Slf4j -public class WAFollowUpNoncomplianceOfDirectionsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "followUpNoncomplianceOfDirections"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateFollowUpNoncomplianceOfDirectionsTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_SEND_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAIssueCaseToRespondentFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAIssueCaseToRespondentFT.java deleted file mode 100644 index b9bf4e220b..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAIssueCaseToRespondentFT.java +++ /dev/null @@ -1,287 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAIssueCaseToRespondentFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "issueCaseToRespondent"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateIssueCaseToRespondentTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCancelIssueCaseToRespondentTaskWithReferToJudge() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCancelIssueCaseToRespondentTaskWithReferToLegalOfficer() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCancelIssueCaseToRespondentTaskWithCaseworkerCloseCase() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAIssueDecisionNoticeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAIssueDecisionNoticeFT.java deleted file mode 100644 index 809ea0fd32..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAIssueDecisionNoticeFT.java +++ /dev/null @@ -1,116 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_HEARING_SUMMARY; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; - -@SpringBootTest -@Slf4j -public class WAIssueDecisionNoticeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "issueDecisionNotice"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - private static final String CASEWORKER_CREATE_HEARING_SUMMARY_DATA = "classpath:wa/caseworker-create-hearing-summary-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateIssueDecisionNoticeTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.putAll(caseData(CASEWORKER_CREATE_HEARING_SUMMARY_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CREATE_HEARING_SUMMARY, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessCaseWithdrawalDirectionsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessCaseWithdrawalDirectionsFT.java deleted file mode 100644 index b2eea7b8f9..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessCaseWithdrawalDirectionsFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessCaseWithdrawalDirectionsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processCaseWithdrawalDirections"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessCaseWithdrawalDirectionsTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: {}", newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Withdrawal request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessCorrectionsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessCorrectionsFT.java deleted file mode 100644 index d7e05288ed..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessCorrectionsFT.java +++ /dev/null @@ -1,116 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessCorrectionsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processCorrections"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessCorrectionsTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: {}", newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - - caseData.put("cicCaseReferralTypeForWA", "Corrections"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReListedCaseFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReListedCaseFT.java deleted file mode 100644 index 352e47cd99..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReListedCaseFT.java +++ /dev/null @@ -1,120 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; - -@SpringBootTest -@Slf4j -public class WAProcessDirectionsReListedCaseFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processDirectionsReListedCase"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessDirectionsReListedCaseTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: {}", newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Listed case"); - - hearingCaseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(hearingCaseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReListedCaseWithin5DaysFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReListedCaseWithin5DaysFT.java deleted file mode 100644 index 45f77800f4..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReListedCaseWithin5DaysFT.java +++ /dev/null @@ -1,119 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; - -@SpringBootTest -@Slf4j -public class WAProcessDirectionsReListedCaseWithin5DaysFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processDirectionsReListedCaseWithin5Days"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessDirectionsReListedCaseWithin5DaysTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: {}", newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Listed case (within 5 days)"); - hearingCaseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(hearingCaseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReturnedFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReturnedFT.java deleted file mode 100644 index 2cd58402a5..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessDirectionsReturnedFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessDirectionsReturnedFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processDirectionsReturned"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessDirectionsReturnedTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "New case"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessFurtherEvidenceFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessFurtherEvidenceFT.java deleted file mode 100644 index 7c4ea3d826..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessFurtherEvidenceFT.java +++ /dev/null @@ -1,163 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CITIZEN_DSS_UPDATE_CASE_SUBMISSION; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_DOCUMENT_MANAGEMENT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessFurtherEvidenceFT extends FunctionalTestSuite { - - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processFurtherEvidence"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessFurtherEvidenceTaskOnCitizenUpdateCaseEvent() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - updateCitizenCase(CITIZEN_DSS_UPDATE_CASE_SUBMISSION, id, getCaseData(caseData)); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessFurtherEvidenceTaskOnCaseworkerDocumentManagementEvent() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_DOCUMENT_MANAGEMENT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessListingDirectionsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessListingDirectionsFT.java deleted file mode 100644 index 57dcb4e986..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessListingDirectionsFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessListingDirectionsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processListingDirections"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessListingDirectionsTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Listing directions"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessOtherDirectionsReturnedFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessOtherDirectionsReturnedFT.java deleted file mode 100644 index 719b0ff56c..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessOtherDirectionsReturnedFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessOtherDirectionsReturnedFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processOtherDirectionsReturned"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessOtherDirectionsReturnedTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Other"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessPostponementDirectionsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessPostponementDirectionsFT.java deleted file mode 100644 index 1992af93b5..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessPostponementDirectionsFT.java +++ /dev/null @@ -1,119 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; - -@SpringBootTest -@Slf4j -public class WAProcessPostponementDirectionsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processPostponementDirections"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessPostponementDirectionsTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Postponement request"); - hearingCaseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(hearingCaseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessReinstatementDecisionNoticeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessReinstatementDecisionNoticeFT.java deleted file mode 100644 index d13cd0269f..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessReinstatementDecisionNoticeFT.java +++ /dev/null @@ -1,115 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessReinstatementDecisionNoticeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processReinstatementDecisionNotice"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessReinstatementDecisionNoticeTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Reinstatement request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessRule27DecisionFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessRule27DecisionFT.java deleted file mode 100644 index 863d79fe8c..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessRule27DecisionFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessRule27DecisionFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processRule27Decision"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessRule27DecisionTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Rule 27 request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessSetAsideDirectionsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessSetAsideDirectionsFT.java deleted file mode 100644 index 112a1dfcb3..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessSetAsideDirectionsFT.java +++ /dev/null @@ -1,115 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessSetAsideDirectionsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processSetAsideDirections"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessSetAsideDirectionsTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Set aside request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessStayDirectionsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessStayDirectionsFT.java deleted file mode 100644 index 9f914e6268..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessStayDirectionsFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessStayDirectionsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processStayDirections"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessStayDirectionsTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Stay request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessStrikeOutDirectionsReturnedFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessStrikeOutDirectionsReturnedFT.java deleted file mode 100644 index ec4c08f510..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessStrikeOutDirectionsReturnedFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessStrikeOutDirectionsReturnedFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processStrikeOutDirectionsReturned"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessStrikeOutDirectionsReturnedTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Strike out request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessTimeExtensionDirectionsReturnedFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessTimeExtensionDirectionsReturnedFT.java deleted file mode 100644 index 01caa52cb2..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessTimeExtensionDirectionsReturnedFT.java +++ /dev/null @@ -1,112 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessTimeExtensionDirectionsReturnedFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processTimeExtensionDirectionsReturned"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessTimeExtensionDirectionsReturnedTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Time extension request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessWrittenReasonsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessWrittenReasonsFT.java deleted file mode 100644 index a50aad413a..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAProcessWrittenReasonsFT.java +++ /dev/null @@ -1,115 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CREATE_DRAFT_ORDER; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAProcessWrittenReasonsFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "processWrittenReasons"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_CREATE_DRAFT_ORDER_DATA = "classpath:wa/caseworker-create-draft-order-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessWrittenReasonsTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Written reasons request"); - caseData.putAll(caseData(CASEWORKER_CREATE_DRAFT_ORDER_DATA)); - checkAndUpdateDraftOrderDocument(caseData); - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_CREATE_DRAFT_ORDER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewCorrectionsRequestFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewCorrectionsRequestFT.java deleted file mode 100644 index 06e95ecd11..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewCorrectionsRequestFT.java +++ /dev/null @@ -1,108 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewCorrectionsRequestFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewCorrectionsRequest"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewCorrectionsRequestTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Corrections"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseJudgeFT.java deleted file mode 100644 index 4e74ea1fed..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseJudgeFT.java +++ /dev/null @@ -1,114 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewListCaseJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewListCaseJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewListCaseJudgeTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Listed case"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseLOFT.java deleted file mode 100644 index fa67743a92..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseLOFT.java +++ /dev/null @@ -1,114 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewListCaseLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewListCaseLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewListCaseLOTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Listed case"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseWithin5DaysJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseWithin5DaysJudgeFT.java deleted file mode 100644 index 8c0737e3ec..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseWithin5DaysJudgeFT.java +++ /dev/null @@ -1,114 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewListCaseWithin5DaysJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewListCaseWithin5DaysJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewListCaseWithin5DaysJudgeTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Listed case (within 5 days)"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseWithin5DaysLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseWithin5DaysLOFT.java deleted file mode 100644 index 9bdbfef1d8..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListCaseWithin5DaysLOFT.java +++ /dev/null @@ -1,114 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewListCaseWithin5DaysLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewListCaseWithin5DaysLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewListCaseWithin5DaysLOTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Listed case (within 5 days)"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListingDirectionsJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListingDirectionsJudgeFT.java deleted file mode 100644 index 8696a30a26..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListingDirectionsJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewListingDirectionsJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewListingDirectionsJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewListingDirectionsJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Listing directions"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListingDirectionsLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListingDirectionsLOFT.java deleted file mode 100644 index 5f3bd5a457..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewListingDirectionsLOFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewListingDirectionsLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewListingDirectionsLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateProcessListingDirectionsTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: {}", newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Listing directions"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewNewCaseAndProvideDirectionsJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewNewCaseAndProvideDirectionsJudgeFT.java deleted file mode 100644 index a568319e48..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewNewCaseAndProvideDirectionsJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewNewCaseAndProvideDirectionsJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewNewCaseAndProvideDirectionsJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewNewCaseAndProvideDirectionsJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "New case"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewNewCaseAndProvideDirectionsLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewNewCaseAndProvideDirectionsLOFT.java deleted file mode 100644 index 73f2d3ca3f..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewNewCaseAndProvideDirectionsLOFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewNewCaseAndProvideDirectionsLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewNewCaseAndProvideDirectionsLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewNewCaseAndProvideDirectionsLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "New case"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewOtherRequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewOtherRequestJudgeFT.java deleted file mode 100644 index c8dda68877..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewOtherRequestJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewOtherRequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewOtherRequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewOtherRequestJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Other"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewOtherRequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewOtherRequestLOFT.java deleted file mode 100644 index ba82720c6f..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewOtherRequestLOFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewOtherRequestLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewOtherRequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewOtherRequestLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Other"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewPostponementRequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewPostponementRequestJudgeFT.java deleted file mode 100644 index 0171f079e5..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewPostponementRequestJudgeFT.java +++ /dev/null @@ -1,114 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewPostponementRequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewPostponementRequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewPostponementRequestJudgeTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Postponement request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewPostponementRequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewPostponementRequestLOFT.java deleted file mode 100644 index fc2a4c84f0..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewPostponementRequestLOFT.java +++ /dev/null @@ -1,114 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewPostponementRequestLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewPostponementRequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewPostponementRequestLOTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - final Map hearingCaseData = ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - hearingCaseData.put("cicCaseReferralTypeForWA", "Postponement request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, hearingCaseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewReinstatementRequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewReinstatementRequestJudgeFT.java deleted file mode 100644 index 7c8951afad..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewReinstatementRequestJudgeFT.java +++ /dev/null @@ -1,108 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewReinstatementRequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewReinstatementRequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewReinstatementRequestJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Reinstatement request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewReinstatementRequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewReinstatementRequestLOFT.java deleted file mode 100644 index 7828a9699a..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewReinstatementRequestLOFT.java +++ /dev/null @@ -1,108 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewReinstatementRequestLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewReinstatementRequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewReinstatementRequestLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Reinstatement request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewRule27RequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewRule27RequestJudgeFT.java deleted file mode 100644 index 86f45db7dc..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewRule27RequestJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewRule27RequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewRule27RequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewRule27RequestJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Rule 27 request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewRule27RequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewRule27RequestLOFT.java deleted file mode 100644 index b863288503..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewRule27RequestLOFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewRule27RequestLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewRule27RequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewRule27RequestLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Rule 27 request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewSetAsideRequestFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewSetAsideRequestFT.java deleted file mode 100644 index eb4461979c..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewSetAsideRequestFT.java +++ /dev/null @@ -1,108 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewSetAsideRequestFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewSetAsideRequest"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewSetAsideRequestTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Set aside request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStayRequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStayRequestJudgeFT.java deleted file mode 100644 index 5bd9f80d0e..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStayRequestJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewStayRequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewStayRequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewStayRequestJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Stay request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStayRequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStayRequestLOFT.java deleted file mode 100644 index d7c698306d..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStayRequestLOFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewStayRequestLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewStayRequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewStayRequestLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Stay request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStrikeOutRequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStrikeOutRequestJudgeFT.java deleted file mode 100644 index 04faa98b12..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStrikeOutRequestJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewStrikeOutRequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewStrikeOutRequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewStrikeOutRequestJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Strike out request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStrikeOutRequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStrikeOutRequestLOFT.java deleted file mode 100644 index 0204cc5040..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewStrikeOutRequestLOFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewStrikeOutRequestLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewStrikeOutRequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewStrikeOutRequestLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Strike out request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewTimeExtensionRequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewTimeExtensionRequestJudgeFT.java deleted file mode 100644 index 7111e98d5f..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewTimeExtensionRequestJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewTimeExtensionRequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewTimeExtensionRequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewTimeExtensionRequestJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Time extension request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewTimeExtensionRequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewTimeExtensionRequestLOFT.java deleted file mode 100644 index f8c7009d5b..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewTimeExtensionRequestLOFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewTimeExtensionRequestLOFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewTimeExtensionRequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewTimeExtensionRequestLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Time extension request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWithdrawalRequestJudgeFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWithdrawalRequestJudgeFT.java deleted file mode 100644 index 6a2d0600b8..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWithdrawalRequestJudgeFT.java +++ /dev/null @@ -1,105 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewWithdrawalRequestJudgeFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewWithdrawalRequestJudge"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewWithdrawalRequestJudgeTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Withdrawal request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWithdrawalRequestLOFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWithdrawalRequestLOFT.java deleted file mode 100644 index fd834d7b29..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWithdrawalRequestLOFT.java +++ /dev/null @@ -1,106 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_LEGAL_OFFICER; - -@SpringBootTest -@Slf4j -public class WAReviewWithdrawalRequestLOFT extends FunctionalTestSuite { - - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewWithdrawalRequestLO"; - private static final List TASK_ROLES = Arrays.asList("tribunal-caseworker", "senior-tribunal-caseworker", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateReviewWithdrawalRequestLOTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: {}", newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Withdrawal request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_LEGAL_OFFICER, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWrittenReasonsRequestFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWrittenReasonsRequestFT.java deleted file mode 100644 index e9ee3d74a0..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAReviewWrittenReasonsRequestFT.java +++ /dev/null @@ -1,108 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CLOSE_THE_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_REFER_TO_JUDGE; - -@SpringBootTest -@Slf4j -public class WAReviewWrittenReasonsRequestFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "reviewWrittenReasonsRequest"; - private static final List TASK_ROLES = Arrays.asList("judge", "senior-judge", "task-supervisor"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldReviewWrittenReasonsRequestTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CLOSE_THE_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.put("cicCaseReferralTypeForWA", "Written reasons request"); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_REFER_TO_JUDGE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 3, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAStitchCollateHearingBundleFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAStitchCollateHearingBundleFT.java deleted file mode 100644 index b5b4698cb1..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAStitchCollateHearingBundleFT.java +++ /dev/null @@ -1,256 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.systemupdate.event.SystemTriggerStitchCollateHearingBundle.SYSTEM_TRIGGER_STITCH_COLLATE_HEARING_BUNDLE; -import static uk.gov.hmcts.sptribs.testutil.CaseDataUtil.caseData; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CANCEL_HEARING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_POSTPONE_HEARING; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_RECORD_LISTING; - -@SpringBootTest -@Slf4j -public class WAStitchCollateHearingBundleFT extends FunctionalTestSuite { - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "stitchCollateHearingBundle"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - private static final String CASEWORKER_RECORD_LISTING_DATA = "classpath:wa/caseworker-record-listing-submit-data.json"; - private static final String CASEWORKER_CANCEL_HEARING_DATA = "classpath:wa/caseworker-cancel-hearing-submit-data.json"; - private static final String CASEWORKER_POSTPONE_HEARING_DATA = "classpath:wa/caseworker-postpone-hearing-submit-data.json"; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateStitchCollateHearingBundleTask() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - ccdCaseCreator.createInitialStartEventAndSubmitSystemEvent( - SYSTEM_TRIGGER_STITCH_COLLATE_HEARING_BUNDLE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCancelStitchCollateHearingBundleWithCaseworkerPostponeHearing() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - ccdCaseCreator.createInitialStartEventAndSubmitSystemEvent( - SYSTEM_TRIGGER_STITCH_COLLATE_HEARING_BUNDLE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - caseData.putAll(caseData(CASEWORKER_POSTPONE_HEARING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_POSTPONE_HEARING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCancelStitchCollateHearingBundleWithCaseworkerCancelHearing() throws IOException { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_CASE_BUILT, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - caseData.putAll(caseData(CASEWORKER_RECORD_LISTING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_RECORD_LISTING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - ccdCaseCreator.createInitialStartEventAndSubmitSystemEvent( - SYSTEM_TRIGGER_STITCH_COLLATE_HEARING_BUNDLE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - caseData.putAll(caseData(CASEWORKER_CANCEL_HEARING_DATA)); - ccdCaseCreator.createInitialStartEventAndSubmit( - CASEWORKER_CANCEL_HEARING, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WATaskRegisterNewCaseFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WATaskRegisterNewCaseFT.java deleted file mode 100644 index d51d620343..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WATaskRegisterNewCaseFT.java +++ /dev/null @@ -1,184 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Value; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.io.IOException; -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WATaskRegisterNewCaseFT extends FunctionalTestSuite { - - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - @Value("${idam.waregionalhearingcentreteamlead.uid}") - private String waRegionalHearingCentreTeamLeadUid; - - private static final String TASK_TYPE = "registerNewCase"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - public void shouldInitiateRegisterNewCaseTask() throws IOException, InterruptedException { - String newCaseId = String.valueOf(createAndSubmitCitizenCaseAndGetCaseReference()); - - log.debug("New case created: {}", newCaseId); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldCompleteRegisterNewCaseWithEditCase() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: {}", newCaseId); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaRegionalHearingCentreTeamLead(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - String taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - assertThat(taskState).isEqualTo("unassigned"); - - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - taskManagementService.assignTask(taskId); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - List> assignedTasks = searchByCaseIdResponseBody.getBody().path("tasks"); - String assignedTaskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(assignedTasks); - assertThat(assignedTasks).isNotEmpty(); - assertThat(assignedTaskType).isEqualTo(TASK_TYPE); - - String assignedTaskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - String assignedTaskUid = searchByCaseIdResponseBody.getBody().path("tasks[0].assignee"); - assertThat(assignedTaskState).isEqualTo("assigned"); - assertThat(assignedTaskUid).isEqualTo(waRegionalHearingCentreTeamLeadUid); - - ccdCaseCreator.createInitialStartEventAndSubmitAdminEvent( - CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - taskManagementService.completeTask(taskId); - - searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - log.info(taskId); - log.info(searchByCaseIdResponseBody.asPrettyString()); - taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - taskState = searchByCaseIdResponseBody.getBody().path("tasks[0].task_state"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - //Completed tasks are marked as "termintated" with a termination_reason "completed" but this field can't be retrieved - assertThat(taskState).isEqualTo("terminated"); - - return true; - }); - } -} diff --git a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAVetNewCaseDocumentsFT.java b/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAVetNewCaseDocumentsFT.java deleted file mode 100644 index d37517e53e..0000000000 --- a/src/functionalTest/java/uk/gov/hmcts/sptribs/wa/WAVetNewCaseDocumentsFT.java +++ /dev/null @@ -1,100 +0,0 @@ -package uk.gov.hmcts.sptribs.wa; - -import io.restassured.response.Response; -import lombok.extern.slf4j.Slf4j; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import uk.gov.hmcts.reform.ccd.client.model.CaseDetails; -import uk.gov.hmcts.sptribs.testutil.CcdCaseCreator; -import uk.gov.hmcts.sptribs.testutil.FunctionalTestSuite; -import uk.gov.hmcts.sptribs.testutil.RoleAssignmentService; -import uk.gov.hmcts.sptribs.testutil.TaskManagementService; - -import java.util.Arrays; -import java.util.List; -import java.util.Map; - -import static java.util.concurrent.TimeUnit.SECONDS; -import static org.assertj.core.api.Assertions.assertThat; -import static org.awaitility.Awaitility.await; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_CASE_TYPE; -import static uk.gov.hmcts.sptribs.testutil.TestConstants.ST_CIC_JURISDICTION; -import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_EDIT_CASE; - -@SpringBootTest -@Slf4j -public class WAVetNewCaseDocumentsFT extends FunctionalTestSuite { - - @Autowired - private CcdCaseCreator ccdCaseCreator; - - @Autowired - private TaskManagementService taskManagementService; - - @Autowired - private RoleAssignmentService roleAssignmentService; - - private static final String TASK_TYPE = "vetNewCaseDocuments"; - private static final List TASK_ROLES = Arrays.asList("regional-centre-admin", "regional-centre-team-leader", "task-supervisor", - "hearing-centre-admin", "hearing-centre-team-leader", "ctsc", "ctsc-team-leader"); - private static final int DEFAULT_TIMEOUT_SECONDS = 300; - private static final int DEFAULT_POLL_INTERVAL_SECONDS = 4; - - @Test - @EnabledIfEnvironmentVariable(named = "WA_FUNCTIONAL_TESTS_ENABLED", matches = "true") - void shouldInitiateVetNewCaseDocumentsTask() { - final CaseDetails caseDetails = createAndSubmitCitizenCaseAndGetCaseDetails(); - final long id = caseDetails.getId(); - final String newCaseId = String.valueOf(id); - final Map caseData = caseDetails.getData(); - - log.debug("New case created: " + newCaseId); - - ccdCaseCreator.createInitialStartEventAndSubmit(CASEWORKER_EDIT_CASE, ST_CIC_JURISDICTION, ST_CIC_CASE_TYPE, newCaseId, caseData); - - await() - .pollInterval(DEFAULT_POLL_INTERVAL_SECONDS, SECONDS) - .atMost(DEFAULT_TIMEOUT_SECONDS, SECONDS) - .until( - () -> { - roleAssignmentService.createRoleAssignmentsForWaSeniorCaseworker(); - - Response searchByCaseIdResponseBody = - taskManagementService.search(newCaseId, List.of(TASK_TYPE), 1, 200); - - if (searchByCaseIdResponseBody.asString().isBlank()) { - return false; - } - - final List> tasks = searchByCaseIdResponseBody.getBody().path("tasks"); - final String taskId = searchByCaseIdResponseBody.getBody().path("tasks[0].id"); - final String taskType = searchByCaseIdResponseBody.getBody().path("tasks[0].type"); - - assertNotNull(tasks); - assertThat(tasks).isNotEmpty(); - assertThat(taskType).isEqualTo(TASK_TYPE); - - Response retrieveTaskRolePermissionsResponseBody = - taskManagementService.retrieveTaskRolePermissions(taskId, 7, 200); - - if (retrieveTaskRolePermissionsResponseBody.asString().isBlank()) { - return false; - } - - final List> roles = retrieveTaskRolePermissionsResponseBody.getBody().path("roles"); - - assertNotNull(roles); - assertThat(roles).isNotEmpty(); - - for (Map role : roles) { - String roleName = role.get("role_name").toString(); - assertThat(roleName).isIn(TASK_ROLES); - } - - return true; - }); - } -} diff --git a/src/functionalTest/resources/application-functional.yaml b/src/functionalTest/resources/application-functional.yaml index b6d23521f0..79589dbb16 100644 --- a/src/functionalTest/resources/application-functional.yaml +++ b/src/functionalTest/resources/application-functional.yaml @@ -17,6 +17,11 @@ spring: servicebus: enabled: false +task-management: + outbox: + poller: + enabled: false + s2s: name: sptribs_case_api ccd_data_name: ccd_data diff --git a/src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-create-bundle-about-to-submit.json b/src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-create-bundle-about-to-submit.json index 3f38057420..31e0733bd1 100644 --- a/src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-create-bundle-about-to-submit.json +++ b/src/functionalTest/resources/request/casedata/ccd-callback-casedata-caseworker-create-bundle-about-to-submit.json @@ -8,6 +8,8 @@ "documentCategory": "ApplicationForm", "documentEmailContent": "Lorem ipsum", "documentLink": { + "document_url": "http://localhost/documents/11111111-1111-1111-1111-111111111111", + "document_binary_url": "http://localhost/documents/11111111-1111-1111-1111-111111111111/binary", "document_filename": "pdf.pdf" } } diff --git a/src/integrationTest/java/uk/gov/hmcts/sptribs/testutil/TaskManagementTestConfiguration.java b/src/integrationTest/java/uk/gov/hmcts/sptribs/testutil/TaskManagementTestConfiguration.java new file mode 100644 index 0000000000..ba403cf375 --- /dev/null +++ b/src/integrationTest/java/uk/gov/hmcts/sptribs/testutil/TaskManagementTestConfiguration.java @@ -0,0 +1,27 @@ +package uk.gov.hmcts.sptribs.testutil; + +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.context.annotation.Primary; +import uk.gov.hmcts.ccd.sdk.taskmanagement.TaskOutboxService; +import uk.gov.hmcts.reform.authorisation.generators.AuthTokenGenerator; + +import static org.mockito.Mockito.mock; + +@Configuration +public class TaskManagementTestConfiguration { + + @Bean + public TaskOutboxService taskOutboxService() { + return mock(TaskOutboxService.class); + } + + @Bean + @Primary + @ConditionalOnProperty(name = "s2s.stub", havingValue = "true") + public AuthTokenGenerator stubAuthTokenGenerator() { + return () -> "Bearer stub-s2s-token"; + } +} + diff --git a/src/integrationTest/resources/application-integration.yaml b/src/integrationTest/resources/application-integration.yaml index c1256b792c..d355a94099 100644 --- a/src/integrationTest/resources/application-integration.yaml +++ b/src/integrationTest/resources/application-integration.yaml @@ -8,8 +8,9 @@ spring: autoconfigure: exclude: - com.azure.spring.cloud.autoconfigure.implementation.context.AzureTokenCredentialAutoConfiguration + - uk.gov.hmcts.ccd.sdk.taskmanagement.TaskManagementAutoConfiguration datasource: - url: jdbc:tc:postgresql:16:///sptribs_case_api + url: jdbc:tc:postgresql:16:///sptribs_case_api?TC_INITSCRIPT=init-task-outbox.sql username: test password: test driver-class-name: org.testcontainers.jdbc.ContainerDatabaseDriver diff --git a/src/integrationTest/resources/init-task-outbox.sql b/src/integrationTest/resources/init-task-outbox.sql new file mode 100644 index 0000000000..c882a7c44f --- /dev/null +++ b/src/integrationTest/resources/init-task-outbox.sql @@ -0,0 +1,24 @@ +CREATE SCHEMA IF NOT EXISTS ccd; + +CREATE TYPE ccd.task_action AS ENUM ('cancel', 'complete', 'initiate', 'reconfigure'); + +CREATE TABLE ccd.task_outbox ( + id bigserial primary key, + case_id text not null, + case_type_id text not null, + payload jsonb not null, + action ccd.task_action not null, + status text not null default 'NEW', + attempt_count integer not null default 0, + created timestamp not null default now(), + updated timestamp not null default now(), + processed timestamp, + next_attempt_at timestamp, + last_response_code integer, + last_error text +); + +CREATE INDEX idx_task_outbox_status_created ON ccd.task_outbox(status, created); +CREATE INDEX idx_task_outbox_status_next_attempt ON ccd.task_outbox(status, next_attempt_at); + + diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCreateHearingSummary.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCreateHearingSummary.java index 1aba5b2881..8fdb1adb93 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCreateHearingSummary.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCreateHearingSummary.java @@ -26,8 +26,10 @@ import uk.gov.hmcts.sptribs.common.ccd.CcdPageConfiguration; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.judicialrefdata.JudicialService; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; +import java.util.List; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_CREATE_HEARING_SUMMARY; import static uk.gov.hmcts.sptribs.caseworker.util.EventUtil.getPanelMembers; @@ -44,6 +46,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.document.DocumentUtil.uploadRecFile; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.completeHearingOutcome; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDecisionNotice; @Component @Slf4j @@ -66,6 +70,9 @@ public class CaseWorkerCreateHearingSummary implements CCDConfig configBuilder) { Event.EventBuilder eventBuilder = @@ -87,8 +94,7 @@ public void configure(final ConfigBuilder configBuild ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, SUPER_USER, - ST_CIC_JUDGE) - .publishToCamunda(); + ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); createHearingSummary.addTo(pageBuilder); @@ -133,6 +139,10 @@ public AboutToStartOrSubmitResponse aboutToSubmit( hearingService.updateHearingList(caseData, hearingName); caseData.getListing().getSummary().setRecFile(new ArrayList<>()); + + taskManagementService.enqueueCompletionTasks(List.of(completeHearingOutcome), details.getId()); + taskManagementService.enqueueInitiationTasks(List.of(issueDecisionNotice), caseData, details.getId()); + return AboutToStartOrSubmitResponse.builder() .data(caseData) .state(AwaitingOutcome) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerIssueDecision.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerIssueDecision.java index 0d0745fadf..037688c081 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerIssueDecision.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerIssueDecision.java @@ -30,9 +30,12 @@ import uk.gov.hmcts.sptribs.document.content.DecisionTemplateContent; import uk.gov.hmcts.sptribs.document.model.CICDocument; import uk.gov.hmcts.sptribs.notification.dispatcher.DecisionIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; +import java.util.List; import static java.lang.String.format; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_ISSUE_DECISION; @@ -74,6 +77,9 @@ public class CaseWorkerIssueDecision implements CCDConfig configBuilder) { Event.EventBuilder eventBuilder = @@ -88,8 +94,7 @@ public void configure(final ConfigBuilder configBuild .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, - ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_JUDGE, ST_CIC_WA_CONFIG_USER) - .publishToCamunda(); + ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_JUDGE, ST_CIC_WA_CONFIG_USER); final PageBuilder pageBuilder = new PageBuilder(eventBuilder); issueDecisionNotice.addTo(pageBuilder); @@ -150,6 +155,11 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) .state(CaseManagement)//or AwaitingHearing diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDate.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDate.java index 1b38f2c93e..f261612f9e 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDate.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDate.java @@ -23,6 +23,7 @@ import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.common.ccd.CcdPageConfiguration; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.Clock; import java.time.LocalDate; @@ -45,6 +46,7 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; @Component @@ -58,6 +60,8 @@ public class CaseWorkerManageOrderDueDate implements CCDConfig configBuilder) { Event.EventBuilder eventBuilder = @@ -73,8 +77,7 @@ public void configure(ConfigBuilder configBuilder) { .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); manageSelectOrderTemplates.addTo(pageBuilder); @@ -111,6 +114,7 @@ public AboutToStartOrSubmitResponse aboutToSubmit(final CaseDet caseData.getCicCase().setOrderList(orderList); caseData.setOrderDueDates(new ArrayList<>()); cicCase.setFirstOrderDueDate(CicCaseFieldsUtil.calculateFirstDueDate(caseData.getCicCase().getOrderList())); + taskManagementService.enqueueCompletionTasks(List.of(followUpNoncomplianceOfDirections), details.getId()); return AboutToStartOrSubmitResponse.builder() .state(details.getState()) .data(caseData) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudge.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudge.java index 0c0719d4c8..15685ea207 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudge.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudge.java @@ -1,6 +1,7 @@ package uk.gov.hmcts.sptribs.caseworker.event; import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import uk.gov.hmcts.ccd.sdk.api.CCDConfig; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -15,6 +16,8 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; +import uk.gov.hmcts.sptribs.taskmanagement.TaskInitiationResolver; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDate; @@ -34,14 +37,18 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.ISSUE_CASE_CANCELLABLE_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.REFERRAL_COMPLETABLE_TASKS; @Component @Slf4j public class CaseWorkerReferToJudge implements CCDConfig { - private final ReferToJudgeReason referToJudgeReason = new ReferToJudgeReason(); private final ReferToJudgeAdditionalInfo referToJudgeAdditionalInfo = new ReferToJudgeAdditionalInfo(); + @Autowired + private TaskManagementService taskManagementService; + @Override public void configure(ConfigBuilder configBuilder) { Event.EventBuilder eventBuilder = @@ -65,8 +72,7 @@ public void configure(ConfigBuilder configBuilder) { ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_WA_CONFIG_USER) .grantHistoryOnly( ST_CIC_SENIOR_JUDGE, - ST_CIC_JUDGE) - .publishToCamunda(); + ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); referToJudgeReason.addTo(pageBuilder); @@ -92,6 +98,17 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) .build(); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficer.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficer.java index 2d1ca5f602..f0a4129255 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficer.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficer.java @@ -1,6 +1,7 @@ package uk.gov.hmcts.sptribs.caseworker.event; import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import uk.gov.hmcts.ccd.sdk.api.CCDConfig; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -15,6 +16,8 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; +import uk.gov.hmcts.sptribs.taskmanagement.TaskInitiationResolver; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDate; @@ -34,14 +37,18 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.ISSUE_CASE_CANCELLABLE_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.REFERRAL_COMPLETABLE_TASKS; @Component @Slf4j public class CaseWorkerReferToLegalOfficer implements CCDConfig { - private final ReferToLegalOfficerReason referToLegalOfficerReason = new ReferToLegalOfficerReason(); private final ReferToLegalOfficerAdditionalInfo referToLegalOfficerAdditionalInfo = new ReferToLegalOfficerAdditionalInfo(); + @Autowired + private TaskManagementService taskManagementService; + @Override public void configure(ConfigBuilder configBuilder) { Event.EventBuilder eventBuilder = @@ -56,8 +63,7 @@ public void configure(ConfigBuilder configBuilder) { .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, - ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .publishToCamunda(); + ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER); PageBuilder pageBuilder = new PageBuilder(eventBuilder); referToLegalOfficerReason.addTo(pageBuilder); @@ -83,6 +89,17 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) .build(); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNote.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNote.java index 9069a67cc3..e55c9db46d 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNote.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNote.java @@ -60,7 +60,7 @@ public void configure(final ConfigBuilder configBuild .aboutToSubmitCallback(this::aboutToSubmit) .grant(CREATE_READ_UPDATE, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, - ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, SUPER_USER, ST_CIC_WA_CONFIG_USER).publishToCamunda(); + ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, SUPER_USER, ST_CIC_WA_CONFIG_USER); new PageBuilder(eventBuilder) .page("addCaseNotes") diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearing.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearing.java index d50618a313..5099353fb9 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearing.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearing.java @@ -25,8 +25,10 @@ import uk.gov.hmcts.sptribs.common.ccd.CcdPageConfiguration; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.notification.dispatcher.CancelHearingNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDate; +import java.util.List; import static java.lang.String.format; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_CANCEL_HEARING; @@ -42,6 +44,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.completeHearingOutcome; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.stitchCollateHearingBundle; @Component @Slf4j @@ -55,12 +59,15 @@ public class CaseworkerCancelHearing implements CCDConfig configBuild .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); final PageBuilder pageBuilder = new PageBuilder(eventBuilder); hearingDateSelect.addTo(pageBuilder); @@ -115,6 +121,10 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCaseBuilt.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCaseBuilt.java index 989aa2fc6f..39658dceee 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCaseBuilt.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCaseBuilt.java @@ -1,16 +1,21 @@ package uk.gov.hmcts.sptribs.caseworker.event; +import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Component; import uk.gov.hmcts.ccd.sdk.api.CCDConfig; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; import uk.gov.hmcts.ccd.sdk.api.ConfigBuilder; import uk.gov.hmcts.ccd.sdk.api.Event; +import uk.gov.hmcts.ccd.sdk.api.callback.AboutToStartOrSubmitResponse; import uk.gov.hmcts.reform.ccd.client.model.SubmittedCallbackResponse; import uk.gov.hmcts.sptribs.ciccase.model.CaseData; import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_CASE_BUILT; import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseManagement; @@ -24,11 +29,16 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueCaseToRespondent; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.vetNewCaseDocuments; @Component @Slf4j +@RequiredArgsConstructor public class CaseworkerCaseBuilt implements CCDConfig { + private final TaskManagementService taskManagementService; + @Override public void configure(final ConfigBuilder configBuilder) { Event.EventBuilder eventBuilder = @@ -36,12 +46,12 @@ public void configure(final ConfigBuilder configBuild .event(CASEWORKER_CASE_BUILT) .forStateTransition(Submitted, CaseManagement) .name("Case: Build case") + .aboutToSubmitCallback(this::aboutToSubmit) .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); new PageBuilder(eventBuilder) .page("caseBuilt") @@ -49,6 +59,21 @@ public void configure(final ConfigBuilder configBuild .label("LabelCaseBuilt", ""); } + public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetails details, + CaseDetails beforeDetails) { + taskManagementService.enqueueCompletionTasks(List.of(vetNewCaseDocuments), details.getId()); + taskManagementService.enqueueInitiationTasks( + List.of(issueCaseToRespondent), + details.getData(), + details.getId() + ); + + return AboutToStartOrSubmitResponse.builder() + .data(details.getData()) + .state(CaseManagement) + .build(); + } + public SubmittedCallbackResponse submitted(CaseDetails details, CaseDetails beforeDetails) { diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCloseTheCase.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCloseTheCase.java index 5b9c6e5e12..bd79a0c572 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCloseTheCase.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCloseTheCase.java @@ -33,7 +33,10 @@ import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocumentUpload; import uk.gov.hmcts.sptribs.judicialrefdata.JudicialService; import uk.gov.hmcts.sptribs.notification.dispatcher.CaseWithdrawnNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; +import java.util.Arrays; import java.util.List; import static java.lang.String.format; @@ -74,6 +77,9 @@ public class CaseworkerCloseTheCase implements CCDConfig configBuilder) { @@ -102,8 +108,7 @@ public PageBuilder closeCase(final ConfigBuilder conf .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); return new PageBuilder(eventBuilder); } @@ -170,6 +175,8 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetails> documents = updateUploadedDocumentCategory(uploadedDocuments, false); caseData.getCloseCase().setDocuments(documents); + taskManagementService.enqueueCancellationTasks(Arrays.stream(TaskType.values()).toList(), details.getId()); + return AboutToStartOrSubmitResponse.builder() .data(caseData) .state(CaseClosed) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactParties.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactParties.java index a458d7f348..b2e1be5191 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactParties.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactParties.java @@ -25,6 +25,9 @@ import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.common.event.page.PartiesToContact; import uk.gov.hmcts.sptribs.notification.dispatcher.ContactPartiesNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static java.lang.String.format; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_CONTACT_PARTIES; @@ -48,6 +51,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; @Component @@ -63,6 +68,7 @@ public class CaseworkerContactParties implements CCDConfig configBuilder) { @@ -83,6 +89,7 @@ public void configure(final ConfigBuilder configBuild .name("Case: Contact parties") .showSummary() .aboutToStartCallback(this::aboutToStart) + .aboutToSubmitCallback(this::aboutToSubmit) .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, @@ -94,8 +101,7 @@ public void configure(final ConfigBuilder configBuild ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, SUPER_USER, - ST_CIC_JUDGE) - .publishToCamunda(); + ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); contactPartiesSelectDocument.addTo(pageBuilder); @@ -114,6 +120,18 @@ public AboutToStartOrSubmitResponse aboutToStart(CaseDetails aboutToSubmit(CaseDetails details, + CaseDetails beforeDetails) { + taskManagementService.enqueueCompletionTasks( + List.of(followUpNoncomplianceOfDirections, processFurtherEvidence), + details.getId() + ); + return AboutToStartOrSubmitResponse.builder() + .data(details.getData()) + .state(details.getState()) + .build(); + } + public SubmittedCallbackResponse submitted(CaseDetails details, CaseDetails beforeDetails) { diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrder.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrder.java index 438ae777e2..f9dbbe301d 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrder.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrder.java @@ -40,6 +40,8 @@ import uk.gov.hmcts.sptribs.common.event.page.PreviewDraftOrder; import uk.gov.hmcts.sptribs.document.model.DocumentType; import uk.gov.hmcts.sptribs.notification.dispatcher.NewOrderIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskInitiationResolver; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDate; import java.time.LocalDateTime; @@ -69,6 +71,7 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.document.DocumentUtil.updateCategoryToDocument; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.REVIEW_TASKS_TO_COMPLETE; @Slf4j @Component @@ -86,6 +89,7 @@ public class CaseworkerCreateAndSendOrder implements CCDConfig configBuilder) { .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_SENIOR_JUDGE, ST_CIC_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER); PageBuilder pageBuilder = new PageBuilder(eventBuilder); applyAnonymitySelect.addTo(pageBuilder); @@ -187,6 +190,20 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetails()); caseData.getCicCase().setFirstOrderDueDate(CicCaseFieldsUtil.calculateFirstDueDate(caseData.getCicCase().getOrderList())); + taskManagementService.enqueueCompletionTasks( + REVIEW_TASKS_TO_COMPLETE, + details.getId() + ); + taskManagementService.enqueueInitiationTasks( + TaskInitiationResolver.createAndSendOrderInitiationTasks( + details.getState(), + caseData.getCicCase().getFirstOrderDueDate(), + caseData.getCicCase().getAdminActionRequired() + ), + caseData, + details.getId() + ); + return AboutToStartOrSubmitResponse.builder() .data(caseData) .state(details.getState()) @@ -254,4 +271,5 @@ private void applyAnonymityCaseFlag(CaseData data) { CaseFlagsUtil.addFlag(data, flagDetail); } + } diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundle.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundle.java index 19b5b598dc..bee6d1034b 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundle.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundle.java @@ -24,6 +24,7 @@ import uk.gov.hmcts.sptribs.document.bundling.model.Callback; import uk.gov.hmcts.sptribs.document.model.AbstractCaseworkerCICDocument; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocument; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.Clock; import java.time.LocalDateTime; @@ -53,6 +54,7 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.stitchCollateHearingBundle; @Component @Slf4j @@ -61,6 +63,7 @@ public class CaseworkerCreateBundle implements CCDConfig { private final BundlingService bundlingService; + private final TaskManagementService taskManagementService; @Autowired private final Clock clock; @@ -78,8 +81,7 @@ public void configure(final ConfigBuilder configBuild .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_SENIOR_JUDGE, ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_SENIOR_JUDGE, ST_CIC_JUDGE); new PageBuilder(eventBuilder) .page("createBundle") @@ -118,6 +120,7 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrder.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrder.java index 115be493b6..bc9e92543a 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrder.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrder.java @@ -25,6 +25,8 @@ import uk.gov.hmcts.sptribs.common.event.page.CreateDraftOrder; import uk.gov.hmcts.sptribs.common.event.page.DraftOrderMainContentPage; import uk.gov.hmcts.sptribs.common.event.page.PreviewDraftOrder; +import uk.gov.hmcts.sptribs.taskmanagement.TaskInitiationResolver; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.text.SimpleDateFormat; import java.util.ArrayList; @@ -33,6 +35,7 @@ import java.util.Locale; import java.util.UUID; import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Stream; import static org.springframework.util.CollectionUtils.isEmpty; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_CREATE_DRAFT_ORDER; @@ -51,6 +54,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.REVIEW_TASKS_TO_COMPLETE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.createDueDate; @Slf4j @Component @@ -58,12 +63,12 @@ public class CaseworkerCreateDraftOrder implements CCDConfig { private final SimpleDateFormat simpleDateFormat = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss", Locale.ENGLISH); - private static final CcdPageConfiguration createDraftOrder = new CreateDraftOrder(); private static final CcdPageConfiguration draftOrderMainContentPage = new DraftOrderMainContentPage(); private static final CcdPageConfiguration previewOrder = new PreviewDraftOrder("previewDraftOrderPage", CASEWORKER_CREATE_DRAFT_ORDER); private final OrderService orderService; + private final TaskManagementService taskManagementService; @Override public void configure(final ConfigBuilder configBuilder) { @@ -78,8 +83,7 @@ public void configure(final ConfigBuilder configBuild .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); createDraftOrder.addTo(pageBuilder); @@ -143,6 +147,19 @@ public AboutToStartOrSubmitResponse aboutToSubmit(final CaseDet caseData.getCicCase().setOrderTemplateIssued(null); + taskManagementService.enqueueCompletionTasks( + Stream.concat(REVIEW_TASKS_TO_COMPLETE.stream(), Stream.of(createDueDate)).toList(), + details.getId() + ); + taskManagementService.enqueueInitiationTasks( + TaskInitiationResolver.createDraftOrderInitiationTasks( + details.getState(), + caseData.getCicCase().getReferralTypeForWA() + ), + caseData, + details.getId() + ); + return AboutToStartOrSubmitResponse.builder() .state(details.getState()) .data(caseData) @@ -183,4 +200,5 @@ private void addToDraftOrderTemplatesDynamicList(final OrderTemplate orderTempla DynamicListElement element = DynamicListElement.builder().label(templateNamePlusCurrentDate).code(UUID.randomUUID()).build(); orderTemplateDynamicList.getListItems().add(element); } + } diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagement.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagement.java index 8df8f6c0f7..44105f0a01 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagement.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagement.java @@ -18,6 +18,7 @@ import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocument; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocumentUpload; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; import java.util.List; @@ -44,6 +45,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.document.DocumentUtil.convertToCaseworkerCICDocumentUpload; import static uk.gov.hmcts.sptribs.document.DocumentUtil.uploadDocument; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; @Component @Slf4j @@ -52,6 +55,7 @@ public class CaseworkerDocumentManagement implements CCDConfig { private final UploadCaseDocuments uploadCaseDocuments = new UploadCaseDocuments(); + private final TaskManagementService taskManagementService; public void configure(final ConfigBuilder configBuilder) { Event.EventBuilder eventBuilder = @@ -75,8 +79,7 @@ public void configure(final ConfigBuilder configBuild ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) .grantHistoryOnly(ST_CIC_JUDGE) .aboutToSubmitCallback(this::aboutToSubmit) - .submittedCallback(this::submitted) - .publishToCamunda(); + .submittedCallback(this::submitted); PageBuilder pageBuilder = new PageBuilder(eventBuilder); uploadCaseDocuments.addTo(pageBuilder); @@ -101,6 +104,9 @@ public AboutToStartOrSubmitResponse aboutToSubmit( } } + taskManagementService.enqueueCompletionTasks(List.of(followUpNoncomplianceOfDirections), details.getId()); + taskManagementService.enqueueInitiationTasks(List.of(processFurtherEvidence), caseData, details.getId()); + return AboutToStartOrSubmitResponse.builder() .data(caseData) .build(); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmend.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmend.java index 119836132e..8ced9f33ad 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmend.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmend.java @@ -2,6 +2,7 @@ import lombok.Setter; import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import uk.gov.hmcts.ccd.sdk.api.CCDConfig; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -21,6 +22,9 @@ import uk.gov.hmcts.sptribs.common.ccd.CcdPageConfiguration; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.document.model.DocumentType; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static uk.gov.hmcts.sptribs.caseworker.util.CaseDocumentListUtil.updateCaseDocumentList; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_DOCUMENT_MANAGEMENT_AMEND; @@ -49,6 +53,7 @@ import static uk.gov.hmcts.sptribs.document.DocumentConstants.DOC_MGMT_TYPE; import static uk.gov.hmcts.sptribs.document.DocumentConstants.HEARING_SUMMARY_TYPE; import static uk.gov.hmcts.sptribs.document.DocumentConstants.REINSTATE_TYPE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; @Component @Slf4j @@ -58,6 +63,9 @@ public class CaseworkerDocumentManagementAmend implements CCDConfig configBuilder) { Event.EventBuilder eventBuilder = configBuilder @@ -82,8 +90,7 @@ public void configure(final ConfigBuilder configBuild .grantHistoryOnly(ST_CIC_JUDGE) .aboutToStartCallback(this::aboutToStart) .aboutToSubmitCallback(this::aboutToSubmit) - .submittedCallback(this::submitted) - .publishToCamunda(); + .submittedCallback(this::submitted); PageBuilder pageBuilder = new PageBuilder(eventBuilder); selectDocuments.addTo(pageBuilder); @@ -176,6 +183,8 @@ public AboutToStartOrSubmitResponse aboutToSubmit( cicCase.setSelectedDocumentCategory(null); cicCase.setSelectedDocumentEmailContent(null); cicCase.setSelectedDocumentLink(null); + taskManagementService.enqueueCompletionTasks(List.of(processFurtherEvidence), details.getId()); + return AboutToStartOrSubmitResponse.builder() .data(data) .build(); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCase.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCase.java index 458dd9be10..5ba59d7cdd 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCase.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCase.java @@ -27,6 +27,10 @@ import uk.gov.hmcts.sptribs.common.event.page.SelectParties; import uk.gov.hmcts.sptribs.common.event.page.SubjectDetails; import uk.gov.hmcts.sptribs.common.service.SubmissionService; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.util.List; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_EDIT_CASE; import static uk.gov.hmcts.sptribs.ciccase.model.State.AwaitingHearing; @@ -45,6 +49,9 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.registerNewCase; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.vetNewCaseDocuments; @Component public class CaseworkerEditCase implements CCDConfig { @@ -61,10 +68,12 @@ public class CaseworkerEditCase implements CCDConfig private static final CcdPageConfiguration editContactPreferenceDetails = new ContactPreferenceDetails(); private final SubmissionService submissionService; + private final TaskManagementService taskManagementService; @Autowired - public CaseworkerEditCase(SubmissionService submissionService) { + public CaseworkerEditCase(SubmissionService submissionService, TaskManagementService taskManagementService) { this.submissionService = submissionService; + this.taskManagementService = taskManagementService; } @Override @@ -106,6 +115,11 @@ && checkNull(data) && !data.getCicCase().getPartiesCIC().contains(PartiesCIC.APP CaseFlagsUtil.updateOrInitialiseFlags(data); CicCaseFieldsUtil.calculateAndSetIsCaseInTime(data); + taskManagementService.enqueueCompletionTasks( + List.of(registerNewCase, processFurtherEvidence), + details.getId() + ); + taskManagementService.enqueueInitiationTasks(getInitiationTaskTypes(state), data, details.getId()); return AboutToStartOrSubmitResponse.builder() .data(data) @@ -132,8 +146,7 @@ private PageBuilder addEventConfig(ConfigBuilder conf ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_RESPONDENT, ST_CIC_WA_CONFIG_USER) .grantHistoryOnly(ST_CIC_JUDGE) .aboutToSubmitCallback(this::aboutToSubmit) - .submittedCallback(this::submitted) - .publishToCamunda(); + .submittedCallback(this::submitted); return new PageBuilder(eventBuilder); } @@ -142,4 +155,11 @@ private boolean checkNull(CaseData data) { return null != data.getCicCase() && null != data.getCicCase().getPartiesCIC(); } + private List getInitiationTaskTypes(State state) { + if (state == Submitted) { + return List.of(vetNewCaseDocuments); + } + return List.of(); + } + } diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrder.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrder.java index 1715d2a459..bf7dfcce82 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrder.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrder.java @@ -74,8 +74,7 @@ public void configure(final ConfigBuilder configBuild .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); editDraftOrder.addTo(pageBuilder); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListing.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListing.java index df4310a33b..8b23998aed 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListing.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListing.java @@ -87,8 +87,7 @@ public void configure(ConfigBuilder configBuilder) { .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); selectHearing.addTo(pageBuilder); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCase.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCase.java index edf66c7a6b..65610b91de 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCase.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCase.java @@ -21,6 +21,7 @@ import uk.gov.hmcts.sptribs.common.ccd.CcdPageConfiguration; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.notification.dispatcher.CaseIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; import java.util.List; @@ -44,6 +45,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.createDueDate; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueCaseToRespondent; @RequiredArgsConstructor @Component @@ -57,6 +60,7 @@ public class CaseworkerIssueCase implements CCDConfig private static final CcdPageConfiguration issueCaseSelectDocument = new IssueCaseSelectDocument(); private final CaseIssuedNotification caseIssuedNotification; + private final TaskManagementService taskManagementService; @Override public void configure(final ConfigBuilder configBuilder) { @@ -73,8 +77,7 @@ public void configure(final ConfigBuilder configBuild .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); issueCaseSelectDocument.addTo(pageBuilder); @@ -92,9 +95,15 @@ public AboutToStartOrSubmitResponse aboutToStart(CaseDetails aboutToSubmit(final CaseDetails details, - final CaseDetails beforeDetails) { + public AboutToStartOrSubmitResponse aboutToSubmit( + final CaseDetails details, + final CaseDetails beforeDetails + ) { final CaseData caseData = details.getData(); + + taskManagementService.enqueueCompletionTasks(List.of(issueCaseToRespondent), details.getId()); + taskManagementService.enqueueInitiationTasks(List.of(createDueDate), caseData, details.getId()); + return AboutToStartOrSubmitResponse.builder() .data(caseData) .state(details.getState()) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecision.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecision.java index 5449077ca4..76e22bdda2 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecision.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecision.java @@ -30,6 +30,7 @@ import uk.gov.hmcts.sptribs.document.content.FinalDecisionTemplateContent; import uk.gov.hmcts.sptribs.document.model.CICDocument; import uk.gov.hmcts.sptribs.notification.dispatcher.CaseFinalDecisionIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; @@ -55,6 +56,7 @@ import static uk.gov.hmcts.sptribs.document.DocumentConstants.FINAL_DECISION_ANNEX_TEMPLATE_ID; import static uk.gov.hmcts.sptribs.document.DocumentConstants.FINAL_DECISION_FILE; import static uk.gov.hmcts.sptribs.document.DocumentUtil.validateDecisionDocumentFormat; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDecisionNotice; @Component @Slf4j @@ -84,6 +86,9 @@ public class CaseworkerIssueFinalDecision implements CCDConfig configBuilder) { Event.EventBuilder eventBuilder = @@ -98,8 +103,7 @@ public void configure(final ConfigBuilder configBuild .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, - ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_JUDGE, ST_CIC_WA_CONFIG_USER) - .publishToCamunda(); + ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_JUDGE, ST_CIC_WA_CONFIG_USER); PageBuilder pageBuilder = new PageBuilder(eventBuilder); issueFinalDecisionNotice.addTo(pageBuilder); @@ -204,6 +208,8 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) .state(CaseClosed) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearing.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearing.java index e82d80a132..3863794bb4 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearing.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearing.java @@ -24,8 +24,11 @@ import uk.gov.hmcts.sptribs.common.ccd.CcdPageConfiguration; import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.notification.dispatcher.HearingPostponedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; import java.time.LocalDate; +import java.util.List; import static java.lang.String.format; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_POSTPONE_HEARING; @@ -41,6 +44,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SUPER_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.HearingBundle; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.HearingCompletion; @Component @Slf4j @@ -49,20 +54,25 @@ public class CaseworkerPostponeHearing implements CCDConfig CANCELLABLE_TASK_TYPES = + TaskType.getTaskTypesFromProcessCategoryIdentifiers(List.of(HearingCompletion, HearingBundle)); private final HearingService hearingService; private final RecordListHelper recordListHelper; private final HearingPostponedNotification hearingPostponedNotification; + private final TaskManagementService taskManagementService; @Autowired public CaseworkerPostponeHearing(HearingService hearingService, RecordListHelper recordListHelper, - HearingPostponedNotification hearingPostponedNotification) { + HearingPostponedNotification hearingPostponedNotification, + TaskManagementService taskManagementService) { this.hearingService = hearingService; this.recordListHelper = recordListHelper; this.hearingPostponedNotification = hearingPostponedNotification; + this.taskManagementService = taskManagementService; } @Override @@ -79,8 +89,7 @@ public void configure(final ConfigBuilder configBuild .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); selectHearing.addTo(pageBuilder); @@ -113,6 +122,8 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) .state(CaseManagement) diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListing.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListing.java index ec7d836bb9..2841220bc4 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListing.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListing.java @@ -90,8 +90,7 @@ public void configure(ConfigBuilder configBuilder) { .grant(CREATE_READ_UPDATE, SUPER_USER, ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_SENIOR_JUDGE, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); hearingTypeAndFormat.addTo(pageBuilder); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrder.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrder.java index 5d3220e559..ced9bbb049 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrder.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrder.java @@ -34,11 +34,14 @@ import uk.gov.hmcts.sptribs.common.ccd.PageBuilder; import uk.gov.hmcts.sptribs.document.model.DocumentType; import uk.gov.hmcts.sptribs.notification.dispatcher.NewOrderIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; import java.time.LocalDate; import java.util.ArrayList; import java.util.EnumSet; import java.util.List; +import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; import static java.lang.String.format; @@ -62,6 +65,27 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.document.DocumentUtil.updateCategoryToDocument; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDueDate; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCaseWithdrawalDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCaseWithdrawalDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCorrections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReListedCase; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReListedCaseWithin5Days; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processListingDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processListingDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processOtherDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processPostponementDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processReinstatementDecisionNotice; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processRule27Decision; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processRule27DecisionListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processSetAsideDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStayDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStayDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStrikeOutDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processTimeExtensionDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processWrittenReasons; @Slf4j @Component @@ -75,7 +99,19 @@ public class CaseworkerSendOrder implements CCDConfig private static final int ORDER_TIMESTAMP_WITH_EXTENSION = 2; //dd-MM-yyyy HH:mm:ss.pdf + private static final Set COMPLETABLE_TASKS = Set.of( + processCaseWithdrawalDirections, processCaseWithdrawalDirectionsListed, + processRule27Decision, processRule27DecisionListed, processListingDirections, + processListingDirectionsListed, processDirectionsReListedCase, + processDirectionsReListedCaseWithin5Days, processSetAsideDirections, processCorrections, + processDirectionsReturned, processPostponementDirections, + processTimeExtensionDirectionsReturned, processReinstatementDecisionNotice, + processOtherDirectionsReturned, processWrittenReasons, processStrikeOutDirectionsReturned, + processStayDirections, processStayDirectionsListed, issueDueDate + ); + private final NewOrderIssuedNotification newOrderIssuedNotification; + private final TaskManagementService taskManagementService; private final SendOrderOrderDueDates orderDueDates; @Override @@ -102,8 +138,7 @@ public PageBuilder send(final ConfigBuilder configBui .submittedCallback(this::submitted) .grant(CREATE_READ_UPDATE, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE); return new PageBuilder(eventBuilder); } @@ -198,6 +233,13 @@ public AboutToStartOrSubmitResponse aboutToSubmit(final CaseDet caseData.setOrderDueDates(new ArrayList<>()); caseData.getCicCase().setFirstOrderDueDate(CicCaseFieldsUtil.calculateFirstDueDate(caseData.getCicCase().getOrderList())); + taskManagementService.enqueueCompletionTasks(COMPLETABLE_TASKS.stream().toList(), details.getId()); + taskManagementService.enqueueInitiationTasks( + getInitiationTaskTypes(details.getState()), + caseData, + details.getId() + ); + return AboutToStartOrSubmitResponse.builder() .data(caseData) .state(details.getState()) @@ -240,4 +282,11 @@ private void sendOrderNotification(String caseNumber, CaseData caseData) { } } + + private List getInitiationTaskTypes(State state) { + if (state == CaseManagement) { + return List.of(followUpNoncomplianceOfDirections); + } + return List.of(); + } } diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerUpdateAnonymity.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerUpdateAnonymity.java index 62f3c98411..4fa43e0f8c 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerUpdateAnonymity.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerUpdateAnonymity.java @@ -43,8 +43,7 @@ public void configure(final ConfigBuilder configBuild .aboutToSubmitCallback(this::aboutToSubmit) .grant(CREATE_READ_UPDATE, ST_CIC_HEARING_CENTRE_ADMIN, ST_CIC_HEARING_CENTRE_TEAM_LEADER, ST_CIC_WA_CONFIG_USER) - .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE) - .publishToCamunda(); + .grantHistoryOnly(ST_CIC_CASEWORKER, ST_CIC_SENIOR_CASEWORKER, ST_CIC_JUDGE, ST_CIC_SENIOR_JUDGE); PageBuilder pageBuilder = new PageBuilder(eventBuilder); applyAnonymity.addTo(pageBuilder); diff --git a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagement.java b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagement.java index e09c640376..81e89b65c8 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagement.java +++ b/src/main/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagement.java @@ -18,6 +18,7 @@ import uk.gov.hmcts.sptribs.common.service.AuditEventService; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocument; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocumentUpload; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; import java.util.List; @@ -46,6 +47,7 @@ import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.document.DocumentUtil.convertToCaseworkerCICDocumentUpload; import static uk.gov.hmcts.sptribs.document.DocumentUtil.uploadDocument; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; @Component @Slf4j @@ -55,6 +57,7 @@ public class RespondentDocumentManagement implements CCDConfig configBuilder) { @@ -84,8 +87,7 @@ public void configure(final ConfigBuilder configBuild ST_CIC_JUDGE, SYSTEM_UPDATE) .aboutToSubmitCallback(this::aboutToSubmit) - .submittedCallback(this::submitted) - .publishToCamunda(); + .submittedCallback(this::submitted); PageBuilder pageBuilder = new PageBuilder(eventBuilder); uploadCaseDocuments.addTo(pageBuilder); @@ -113,6 +115,8 @@ public AboutToStartOrSubmitResponse aboutToSubmit(final CaseDet } } + taskManagementService.enqueueInitiationTasks(List.of(processFurtherEvidence), caseData, details.getId()); + return AboutToStartOrSubmitResponse.builder() .data(caseData) .build(); diff --git a/src/main/java/uk/gov/hmcts/sptribs/ciccase/CriminalInjuriesCompensation.java b/src/main/java/uk/gov/hmcts/sptribs/ciccase/CriminalInjuriesCompensation.java index aa461b75f2..59067ee547 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/ciccase/CriminalInjuriesCompensation.java +++ b/src/main/java/uk/gov/hmcts/sptribs/ciccase/CriminalInjuriesCompensation.java @@ -35,6 +35,7 @@ public void configure(final ConfigBuilder configBuilder) { Event.EventBuilder eventBuilder = @@ -94,7 +99,6 @@ public void configure(final ConfigBuilder configBuild ) .aboutToSubmitCallback(this::aboutToSubmit) .submittedCallback(this::submitted) - .publishToCamunda() .grant(CREATE_READ_UPDATE, ST_CIC_WA_CONFIG_USER); } @@ -102,6 +106,7 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetails beforeDetails) { final CaseData caseData = addDocumentsToCaseData(details.getData(), details.getData().getDssCaseData()); + taskManagementService.enqueueInitiationTasks(List.of(processFurtherEvidence), caseData, details.getId()); return AboutToStartOrSubmitResponse.builder() .data(caseData) diff --git a/src/main/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEvent.java b/src/main/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEvent.java index 1185836427..6e80d2a1fb 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEvent.java +++ b/src/main/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEvent.java @@ -35,6 +35,7 @@ import uk.gov.hmcts.sptribs.document.model.CitizenCICDocument; import uk.gov.hmcts.sptribs.document.model.DocumentType; import uk.gov.hmcts.sptribs.idam.IdamService; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import uk.gov.hmcts.sptribs.util.AppsUtil; import java.time.LocalDate; @@ -63,6 +64,7 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SYSTEM_UPDATE; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE_DELETE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.registerNewCase; @Component @Slf4j @@ -73,14 +75,17 @@ public class CicSubmitCaseEvent implements CCDConfig private IdamService idamService; private AppsConfig appsConfig; private DssApplicationReceivedNotification dssApplicationReceivedNotification; + private TaskManagementService taskManagementService; @Autowired public CicSubmitCaseEvent(HttpServletRequest request, IdamService idamService, AppsConfig appsConfig, - DssApplicationReceivedNotification dssApplicationReceivedNotification) { + DssApplicationReceivedNotification dssApplicationReceivedNotification, + TaskManagementService taskManagementService) { this.request = request; this.idamService = idamService; this.appsConfig = appsConfig; this.dssApplicationReceivedNotification = dssApplicationReceivedNotification; + this.taskManagementService = taskManagementService; } @Override @@ -104,8 +109,7 @@ public void configure(final ConfigBuilder configBuild SUPER_USER, ST_CIC_JUDGE) .aboutToSubmitCallback(this::aboutToSubmit) - .submittedCallback(this::submitted) - .publishToCamunda(); + .submittedCallback(this::submitted); } public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetails details, @@ -114,6 +118,7 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetailsbuilder() .data(caseData) diff --git a/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcome.java b/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcome.java index 453f0f53b8..c934048386 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcome.java +++ b/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcome.java @@ -1,5 +1,6 @@ package uk.gov.hmcts.sptribs.systemupdate.event; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import uk.gov.hmcts.ccd.sdk.api.CCDConfig; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -9,6 +10,9 @@ import uk.gov.hmcts.sptribs.ciccase.model.CaseData; import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static uk.gov.hmcts.sptribs.caseworker.model.YesNo.YES; import static uk.gov.hmcts.sptribs.ciccase.model.State.AwaitingHearing; @@ -16,12 +20,16 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SYSTEM_UPDATE; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE_DELETE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.completeHearingOutcome; @Component public class SystemTriggerCompleteHearingOutcome implements CCDConfig { public static final String SYSTEM_TRIGGER_COMPLETE_HEARING_OUTCOME = "system-trigger-complete-hearing-outcome"; + @Autowired + private TaskManagementService taskManagementService; + @Override public void configure(ConfigBuilder configBuilder) { Event.EventBuilder eventBuilder = configBuilder @@ -31,7 +39,6 @@ public void configure(ConfigBuilder configBuilder) { .description("Trigger hearing outcome") .aboutToSubmitCallback(this::aboutToSubmit) .grant(CREATE_READ_UPDATE_DELETE, SYSTEM_UPDATE) - .publishToCamunda() .grant(CREATE_READ_UPDATE, ST_CIC_WA_CONFIG_USER); } @@ -39,6 +46,7 @@ public AboutToStartOrSubmitResponse aboutToSubmit(CaseDetails beforeDetails) { final CaseData caseData = caseDetails.getData(); caseData.setCompleteHearingOutcomeTask(YES); + taskManagementService.enqueueInitiationTasks(List.of(completeHearingOutcome), caseData, caseDetails.getId()); return AboutToStartOrSubmitResponse.builder() .data(caseData) diff --git a/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundle.java b/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundle.java index a682162885..8fde4228bd 100644 --- a/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundle.java +++ b/src/main/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundle.java @@ -1,5 +1,6 @@ package uk.gov.hmcts.sptribs.systemupdate.event; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import uk.gov.hmcts.ccd.sdk.api.CCDConfig; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -9,6 +10,9 @@ import uk.gov.hmcts.sptribs.ciccase.model.CaseData; import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static uk.gov.hmcts.sptribs.caseworker.model.YesNo.YES; import static uk.gov.hmcts.sptribs.ciccase.model.State.AwaitingHearing; @@ -16,11 +20,15 @@ import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.SYSTEM_UPDATE; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE; import static uk.gov.hmcts.sptribs.ciccase.model.access.Permissions.CREATE_READ_UPDATE_DELETE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.stitchCollateHearingBundle; @Component public class SystemTriggerStitchCollateHearingBundle implements CCDConfig { public static final String SYSTEM_TRIGGER_STITCH_COLLATE_HEARING_BUNDLE = "system-trigger-stitch-collate-hearing-bundle"; + @Autowired + private TaskManagementService taskManagementService; + @Override public void configure(final ConfigBuilder configBuilder) { Event.EventBuilder eventBuilder = configBuilder @@ -30,7 +38,6 @@ public void configure(final ConfigBuilder configBuild .description("Trigger stitch hearing bundle") .aboutToSubmitCallback(this::aboutToSubmit) .grant(CREATE_READ_UPDATE_DELETE, SYSTEM_UPDATE) - .publishToCamunda() .grant(CREATE_READ_UPDATE, ST_CIC_WA_CONFIG_USER); } @@ -39,6 +46,11 @@ public AboutToStartOrSubmitResponse aboutToSubmit(final CaseDet final CaseDetails beforeDetails) { CaseData caseData = details.getData(); caseData.setStitchHearingBundleTask(YES); + taskManagementService.enqueueInitiationTasks( + List.of(stitchCollateHearingBundle), + caseData, + details.getId() + ); return AboutToStartOrSubmitResponse.builder() .data(caseData) diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskConstants.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskConstants.java new file mode 100644 index 0000000000..46306b736a --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskConstants.java @@ -0,0 +1,190 @@ +package uk.gov.hmcts.sptribs.taskmanagement; + +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.util.Set; + +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewCorrectionsRequest; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseWithin5DaysJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseWithin5DaysLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewNewCaseAndProvideDirectionsJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewNewCaseAndProvideDirectionsLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOtherRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOtherRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewPostponementRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewPostponementRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewReinstatementRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewReinstatementRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewSetAsideRequest; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStrikeOutRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStrikeOutRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewTimeExtensionRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewTimeExtensionRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWrittenReasonsRequest; + +public final class TaskConstants { + + public static final String JURISDICTION = "ST_CIC"; + public static final String DEFAULT_REGION = "1"; + public static final String DEFAULT_LOCATION = "336559"; + public static final String DEFAULT_EXECUTION_TYPE = "Case Management Task"; + public static final String DEFAULT_SECURITY_CLASSIFICATION = "PUBLIC"; + public static final String DEFAULT_TASK_SYSTEM = "SELF"; + public static final int MAJOR_PRIORITY = 5000; + public static final int MINOR_PRIORITY = 500; + + public static final String GLASGOW_TRIBUNALS_CENTRE = "Glasgow Tribunals Centre"; + public static final String CRIMINAL_INJURIES_COMPENSATION = "Criminal Injuries Compensation"; + public static final String CIC_CASE_TYPE = "CriminalInjuriesCompensation"; + + public static final String EMPTY_DESCRIPTION = ""; + public static final String SEND_ORDER_DESCRIPTION = + "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-send-order)"; + public static final String ISSUE_DECISION_DESCRIPTION = + "[Decision: Issue a decision](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-issue-decision)" + + "
" + + "[Decision: Issue final decision]" + + "(/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-issue-final-decision)"; + public static final String COMPLETE_HEARING_OUTCOME_DESCRIPTION = + "[Hearings:Create summary](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-hearing-summary)"; + public static final String ISSUE_CASE_TO_RESPONDENT_DESCRIPTION = + "[Case: Issue to respondent](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-issue-case)"; + public static final String VET_NEW_CASE_DOCUMENTS_DESCRIPTION = + "[Case: Build case](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-case-built)"; + public static final String CREATE_DUE_DATE_DESCRIPTION = + "[Orders: Create draft](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-draft-order)"; + public static final String REVIEW_REQUESTS_DESCRIPTION = + "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)"; + public static final String FOLLOW_UP_NONCOMPLIANCE_DESCRIPTION = + "[Document management: Upload](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-document-management)" + + "
" + + "[Orders: Manage due date](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-amend-due-date)" + + "
" + + "[Refer case to judge](/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-judge)" + + "
" + + "[Refer case to legal officer]" + + "(/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-legal-officer)" + + "
" + + "[Case: Contact parties](/cases/case-details/${[CASE_REFERENCE]}/trigger/contact-parties)"; + public static final String REGISTER_NEW_CASE_DESCRIPTION = + "[Case: Edit case](/cases/case-details/${[CASE_REFERENCE]}/trigger/edit-case)"; + public static final String STITCH_COLLATE_BUNDLE_DESCRIPTION = + "[Bundle: Create a bundle](/cases/case-details/${[CASE_REFERENCE]}/trigger/createBundle)"; + public static final String PROCESS_FURTHER_EVIDENCE_DESCRIPTION = + "[Document management: Amend](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-amend-document)" + + "
" + + "[Case: Edit case](/cases/case-details/${[CASE_REFERENCE]}/trigger/edit-case)" + + "
" + + "[Refer case to judge](/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-judge)" + + "
" + + "[Refer case to legal officer]" + + "(/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-legal-officer)" + + "
" + + "[Case: Contact parties](/cases/case-details/${[CASE_REFERENCE]}/trigger/contact-parties)"; + + public static final String RULE_27_DESCRIPTION = + "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-send-order)"; + + + public static final Set REVIEW_REQUESTS_TASKS = Set.of( + reviewNewCaseAndProvideDirectionsLO, + reviewTimeExtensionRequestLO, + reviewStrikeOutRequestLO, + reviewStayRequestLO, + reviewStayRequestCaseListedLO, + reviewListingDirectionsLO, + reviewListingDirectionsCaseListedLO, + reviewWithdrawalRequestLO, + reviewRule27RequestLO, + reviewListCaseLO, + reviewOtherRequestLO, + reviewListCaseWithin5DaysLO, + reviewPostponementRequestLO, + reviewReinstatementRequestLO, + reviewListCaseWithin5DaysJudge, + reviewPostponementRequestJudge, + reviewCorrectionsRequest, + reviewWrittenReasonsRequest, + reviewReinstatementRequestJudge, + reviewSetAsideRequest, + reviewStayRequestJudge, + reviewNewCaseAndProvideDirectionsJudge, + reviewOtherRequestJudge, + reviewWithdrawalRequestJudge, + reviewRule27RequestJudge, + reviewListingDirectionsJudge, + reviewListingDirectionsCaseListedJudge, + reviewListCaseJudge, + reviewStrikeOutRequestJudge, + reviewTimeExtensionRequestJudge, + reviewRule27RequestCaseListedLO, + reviewWithdrawalRequestCaseListedLO, + reviewWithdrawalRequestCaseListedJudge, + reviewStayRequestCaseListedJudge, + reviewRule27RequestCaseListedJudge + ); + + public static final Set LEGAL_OPERATIONS_TASKS = Set.of( + reviewNewCaseAndProvideDirectionsLO, + reviewTimeExtensionRequestLO, + reviewStrikeOutRequestLO, + reviewStayRequestLO, + reviewStayRequestCaseListedLO, + reviewListingDirectionsLO, + reviewListingDirectionsCaseListedLO, + reviewWithdrawalRequestLO, + reviewRule27RequestLO, + reviewListCaseLO, + reviewOtherRequestLO, + reviewListCaseWithin5DaysLO, + reviewPostponementRequestLO, + reviewReinstatementRequestLO, + reviewRule27RequestCaseListedLO, + reviewWithdrawalRequestCaseListedLO + ); + + public static final Set JUDICIAL_TASKS = Set.of( + reviewListCaseWithin5DaysJudge, + reviewPostponementRequestJudge, + reviewCorrectionsRequest, + reviewWrittenReasonsRequest, + reviewReinstatementRequestJudge, + reviewSetAsideRequest, + reviewStayRequestJudge, + reviewNewCaseAndProvideDirectionsJudge, + reviewOtherRequestJudge, + reviewWithdrawalRequestJudge, + reviewRule27RequestJudge, + reviewListingDirectionsJudge, + reviewListingDirectionsCaseListedJudge, + reviewListCaseJudge, + reviewStrikeOutRequestJudge, + reviewTimeExtensionRequestJudge, + reviewWithdrawalRequestCaseListedJudge, + reviewStayRequestCaseListedJudge, + reviewRule27RequestCaseListedJudge + ); + + private TaskConstants() { + } +} + + diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskInitiationResolver.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskInitiationResolver.java new file mode 100644 index 0000000000..89398b6fc5 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskInitiationResolver.java @@ -0,0 +1,333 @@ +package uk.gov.hmcts.sptribs.taskmanagement; + +import uk.gov.hmcts.sptribs.ciccase.model.AdminAction; +import uk.gov.hmcts.sptribs.ciccase.model.State; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.List; +import java.util.Set; + +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.CORRECTIONS; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.LISTED_CASE; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.LISTED_CASE_WITHIN_5_DAYS; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.LISTING_DIRECTIONS; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.NEW_CASE; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.OTHER; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.POSTPONEMENT_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.REINSTATEMENT_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.RULE_27_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.SET_ASIDE_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.STAY_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.STRIKE_OUT_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.TIME_EXTENSION_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.WITHDRAWAL_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.WRITTEN_REASONS_REQUEST; +import static uk.gov.hmcts.sptribs.ciccase.model.AdminAction.ADMIN_ACTION_REQUIRED; +import static uk.gov.hmcts.sptribs.ciccase.model.State.AwaitingHearing; +import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseClosed; +import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseManagement; +import static uk.gov.hmcts.sptribs.ciccase.model.State.ReadyToList; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDueDate; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCaseWithdrawalDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCaseWithdrawalDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCorrections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReListedCase; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReListedCaseWithin5Days; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processListingDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processListingDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processOtherDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processPostponementDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processReinstatementDecisionNotice; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processRule27Decision; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processRule27DecisionListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processSetAsideDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStayDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStayDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStrikeOutDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processTimeExtensionDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processWrittenReasons; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewCorrectionsRequest; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseWithin5DaysJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseWithin5DaysLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewNewCaseAndProvideDirectionsJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewNewCaseAndProvideDirectionsLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOrder; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOtherRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOtherRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewPostponementRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewPostponementRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewReinstatementRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewReinstatementRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewSetAsideRequest; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStrikeOutRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStrikeOutRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewTimeExtensionRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewTimeExtensionRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWrittenReasonsRequest; + +public final class TaskInitiationResolver { + + private TaskInitiationResolver() { + } + + public static List createDraftOrderInitiationTasks(State state, String referralType) { + if (state == CaseManagement && (referralType == null || referralType.isBlank())) { + return List.of(issueDueDate); + } + + if (WITHDRAWAL_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(processCaseWithdrawalDirectionsListed); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(processCaseWithdrawalDirections); + } + } + + if (RULE_27_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(processRule27DecisionListed); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(processRule27Decision); + } + } + + if (LISTING_DIRECTIONS.getLabel().equals(referralType)) { + if (state == CaseManagement) { + return List.of(processListingDirections); + } + if (state == ReadyToList) { + return List.of(processListingDirectionsListed); + } + } + + if (LISTED_CASE.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(processDirectionsReListedCase); + } + + if (LISTED_CASE_WITHIN_5_DAYS.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(processDirectionsReListedCaseWithin5Days); + } + + if (SET_ASIDE_REQUEST.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(processSetAsideDirections); + } + + if (CORRECTIONS.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(processCorrections); + } + + if (NEW_CASE.getLabel().equals(referralType) && (state == CaseManagement || state == ReadyToList)) { + return List.of(processDirectionsReturned); + } + + if (POSTPONEMENT_REQUEST.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(processPostponementDirections); + } + + if (TIME_EXTENSION_REQUEST.getLabel().equals(referralType) + && (state == CaseManagement || state == ReadyToList)) { + return List.of(processTimeExtensionDirectionsReturned); + } + + if (REINSTATEMENT_REQUEST.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(processReinstatementDecisionNotice); + } + + if (OTHER.getLabel().equals(referralType)) { + return List.of(processOtherDirectionsReturned); + } + + if (WRITTEN_REASONS_REQUEST.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(processWrittenReasons); + } + + if (STRIKE_OUT_REQUEST.getLabel().equals(referralType) + && (state == CaseManagement || state == ReadyToList)) { + return List.of(processStrikeOutDirectionsReturned); + } + + if (STAY_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(processStayDirectionsListed); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(processStayDirections); + } + } + + return List.of(); + } + + public static List referToJudgeInitiationTasks(State state, String referralType) { + if (LISTED_CASE_WITHIN_5_DAYS.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(reviewListCaseWithin5DaysJudge); + } + if (POSTPONEMENT_REQUEST.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(reviewPostponementRequestJudge); + } + if (CORRECTIONS.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(reviewCorrectionsRequest); + } + if (WRITTEN_REASONS_REQUEST.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(reviewWrittenReasonsRequest); + } + if (REINSTATEMENT_REQUEST.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(reviewReinstatementRequestJudge); + } + if (SET_ASIDE_REQUEST.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(reviewSetAsideRequest); + } + if (STAY_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(reviewStayRequestCaseListedJudge); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(reviewStayRequestJudge); + } + } + if (NEW_CASE.getLabel().equals(referralType) && (state == CaseManagement || state == ReadyToList)) { + return List.of(reviewNewCaseAndProvideDirectionsJudge); + } + if (OTHER.getLabel().equals(referralType)) { + return List.of(reviewOtherRequestJudge); + } + if (WITHDRAWAL_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(reviewWithdrawalRequestCaseListedJudge); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(reviewWithdrawalRequestJudge); + } + } + if (RULE_27_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(reviewRule27RequestCaseListedJudge); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(reviewRule27RequestJudge); + } + } + if (LISTING_DIRECTIONS.getLabel().equals(referralType)) { + if (state == CaseManagement) { + return List.of(reviewListingDirectionsJudge); + } + if (state == ReadyToList) { + return List.of(reviewListingDirectionsCaseListedJudge); + } + } + if (LISTED_CASE.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(reviewListCaseJudge); + } + if (STRIKE_OUT_REQUEST.getLabel().equals(referralType) + && (state == CaseManagement || state == ReadyToList)) { + return List.of(reviewStrikeOutRequestJudge); + } + if (TIME_EXTENSION_REQUEST.getLabel().equals(referralType) + && (state == CaseManagement || state == ReadyToList)) { + return List.of(reviewTimeExtensionRequestJudge); + } + return List.of(); + } + + public static List referToLegalOfficerInitiationTasks(State state, String referralType) { + if (NEW_CASE.getLabel().equals(referralType) && (state == CaseManagement || state == ReadyToList)) { + return List.of(reviewNewCaseAndProvideDirectionsLO); + } + if (TIME_EXTENSION_REQUEST.getLabel().equals(referralType) + && (state == CaseManagement || state == ReadyToList)) { + return List.of(reviewTimeExtensionRequestLO); + } + if (STRIKE_OUT_REQUEST.getLabel().equals(referralType) + && (state == CaseManagement || state == ReadyToList)) { + return List.of(reviewStrikeOutRequestLO); + } + if (STAY_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(reviewStayRequestCaseListedLO); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(reviewStayRequestLO); + } + } + if (LISTING_DIRECTIONS.getLabel().equals(referralType)) { + if (state == CaseManagement) { + return List.of(reviewListingDirectionsLO); + } + if (state == ReadyToList) { + return List.of(reviewListingDirectionsCaseListedLO); + } + } + if (WITHDRAWAL_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(reviewWithdrawalRequestCaseListedLO); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(reviewWithdrawalRequestLO); + } + } + if (RULE_27_REQUEST.getLabel().equals(referralType)) { + if (state == AwaitingHearing) { + return List.of(reviewRule27RequestCaseListedLO); + } + if (state == CaseManagement || state == ReadyToList) { + return List.of(reviewRule27RequestLO); + } + } + if (LISTED_CASE.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(reviewListCaseLO); + } + if (LISTED_CASE_WITHIN_5_DAYS.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(reviewListCaseWithin5DaysLO); + } + if (POSTPONEMENT_REQUEST.getLabel().equals(referralType) && state == AwaitingHearing) { + return List.of(reviewPostponementRequestLO); + } + if (REINSTATEMENT_REQUEST.getLabel().equals(referralType) && state == CaseClosed) { + return List.of(reviewReinstatementRequestLO); + } + if (OTHER.getLabel().equals(referralType)) { + return List.of(reviewOtherRequestLO); + } + return List.of(); + } + + public static List createAndSendOrderInitiationTasks( + State state, + LocalDate firstOrderDueDate, + Set adminActionRequired + ) { + List taskTypes = new ArrayList<>(); + if (state == CaseManagement && firstOrderDueDate != null) { + taskTypes.add(followUpNoncomplianceOfDirections); + } + + if (adminActionRequired != null && adminActionRequired.contains(ADMIN_ACTION_REQUIRED)) { + taskTypes.add(reviewOrder); + } + return taskTypes; + } +} diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskManagementService.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskManagementService.java new file mode 100644 index 0000000000..e6948463cf --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskManagementService.java @@ -0,0 +1,176 @@ +package uk.gov.hmcts.sptribs.taskmanagement; + +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import uk.gov.hmcts.ccd.sdk.taskmanagement.TaskOutboxService; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.TaskPayload; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.TaskPermission; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.outbox.TerminateTaskOutboxPayload; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.request.TaskCreateRequest; +import uk.gov.hmcts.sptribs.ciccase.model.CaseData; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.List; +import java.util.UUID; + +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.CIC_CASE_TYPE; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.CRIMINAL_INJURIES_COMPENSATION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.DEFAULT_EXECUTION_TYPE; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.DEFAULT_LOCATION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.DEFAULT_REGION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.DEFAULT_SECURITY_CLASSIFICATION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.DEFAULT_TASK_SYSTEM; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.GLASGOW_TRIBUNALS_CENTRE; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.JUDICIAL_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.JURISDICTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.LEGAL_OPERATIONS_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.MAJOR_PRIORITY; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.MINOR_PRIORITY; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.CTSC; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.CTSC_TEAM_LEADER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.HEARING_CENTRE_ADMIN; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.HEARING_CENTRE_TEAM_LEADER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.JUDGE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.REGIONAL_CENTRE_ADMIN; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.REGIONAL_CENTRE_TEAM_LEADER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.SENIOR_JUDGE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.SENIOR_TRIBUNAL_CASEWORKER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.TASK_SUPERVISOR; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskAccess.TRIBUNAL_CASEWORKER; + +@Service +@RequiredArgsConstructor +public class TaskManagementService { + + private final TaskOutboxService taskOutboxService; + + public void enqueueInitiationTasks(List taskTypes, CaseData caseData, long caseId) { + if (taskTypes == null || taskTypes.isEmpty()) { + return; + } + + taskTypes.stream() + .distinct() + .map(taskType -> new TaskCreateRequest(getTaskPayload(taskType, caseData, caseId))) + .forEach(taskOutboxService::enqueueTaskCreateRequest); + } + + public void enqueueCompletionTasks(List taskTypes, long caseId) { + enqueueTaskTermination(taskTypes, caseId, true); + } + + public void enqueueCancellationTasks(List taskTypes, long caseId) { + enqueueTaskTermination(taskTypes, caseId, false); + } + + private void enqueueTaskTermination(List taskTypes, long caseId, boolean completion) { + if (taskTypes == null || taskTypes.isEmpty()) { + return; + } + + TerminateTaskOutboxPayload taskOutboxPayload = new TerminateTaskOutboxPayload( + String.valueOf(caseId), + CIC_CASE_TYPE, + taskTypes.stream().map(Enum::name).toList() + ); + + if (completion) { + taskOutboxService.enqueueTaskCompleteRequest(taskOutboxPayload); + } else { + taskOutboxService.enqueueTaskCancelRequest(taskOutboxPayload); + } + } + + private TaskPayload getTaskPayload(TaskType taskType, CaseData caseData, long caseId) { + return TaskPayload.builder() + .externalTaskId(UUID.randomUUID().toString()) + .name(taskType.getName()) + .type(taskType.name()) + .title(taskType.getName()) + .created(OffsetDateTime.now()) + .executionType(DEFAULT_EXECUTION_TYPE) + .taskSystem(DEFAULT_TASK_SYSTEM) + .caseId(String.valueOf(caseId)) + .jurisdiction(JURISDICTION) + .caseTypeId(CIC_CASE_TYPE) + .securityClassification(getSecurityClassification(caseData)) + .permissions(getTaskPermissions(taskType)) + .priorityDate(getPriorityDate(caseData)) + .caseName(caseData.getCaseNameHmctsInternal()) + .caseCategory(getCaseCategory(caseData)) + .region(getRegion(caseData)) + .location(getLocation(caseData)) + .locationName(GLASGOW_TRIBUNALS_CENTRE) + .majorPriority(MAJOR_PRIORITY) + .minorPriority(MINOR_PRIORITY) + .dueDateTime(OffsetDateTime.now().plusDays(taskType.getDueDateIntervalDays())) + .workType(taskType.getWorkType()) + .roleCategory(taskType.getRoleCategory()) + .description(taskType.getDescription()) + .build(); + } + + private String getSecurityClassification(CaseData caseData) { + if (caseData.getSecurityClass() == null || caseData.getSecurityClass().getLabel() == null) { + return DEFAULT_SECURITY_CLASSIFICATION; + } + return caseData.getSecurityClass().getLabel(); + } + + private List getTaskPermissions(TaskType taskType) { + return getTaskAccess(taskType).stream().map(TaskAccess::toTaskPermission).toList(); + } + + private List getTaskAccess(TaskType taskType) { + if (LEGAL_OPERATIONS_TASKS.contains(taskType)) { + return List.of(SENIOR_TRIBUNAL_CASEWORKER, TRIBUNAL_CASEWORKER, TASK_SUPERVISOR); + } + + if (JUDICIAL_TASKS.contains(taskType)) { + return List.of(SENIOR_JUDGE, JUDGE, TASK_SUPERVISOR); + } + + return List.of( + REGIONAL_CENTRE_ADMIN, + REGIONAL_CENTRE_TEAM_LEADER, + HEARING_CENTRE_ADMIN, + HEARING_CENTRE_TEAM_LEADER, + CTSC, + CTSC_TEAM_LEADER, + TASK_SUPERVISOR + ); + } + + private OffsetDateTime getPriorityDate(CaseData caseData) { + if (caseData.getDueDate() == null) { + return OffsetDateTime.now(); + } + return caseData.getDueDate().atStartOfDay().atOffset(ZoneOffset.UTC); + } + + private String getCaseCategory(CaseData caseData) { + if (caseData.getCaseManagementCategory() == null + || caseData.getCaseManagementCategory().getValueLabel() == null) { + return CRIMINAL_INJURIES_COMPENSATION; + } + return caseData.getCaseManagementCategory().getValueLabel(); + } + + private String getRegion(CaseData caseData) { + if (caseData.getCaseManagementLocation() == null || caseData.getCaseManagementLocation().getRegion() == null) { + return DEFAULT_REGION; + } + return caseData.getCaseManagementLocation().getRegion(); + } + + private String getLocation(CaseData caseData) { + if (caseData.getCaseManagementLocation() == null + || caseData.getCaseManagementLocation().getBaseLocation() == null) { + return DEFAULT_LOCATION; + } + return caseData.getCaseManagementLocation().getBaseLocation(); + } +} diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskTypeCollections.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskTypeCollections.java new file mode 100644 index 0000000000..9603d91168 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/TaskTypeCollections.java @@ -0,0 +1,30 @@ +package uk.gov.hmcts.sptribs.taskmanagement; + +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.util.List; +import java.util.stream.Stream; + +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.IssueCase; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOrder; + +public final class TaskTypeCollections { + + public static final List ISSUE_CASE_CANCELLABLE_TASKS = + TaskType.getTaskTypesFromProcessCategoryIdentifiers(List.of(IssueCase)); + + public static final List REFERRAL_COMPLETABLE_TASKS = + List.of(followUpNoncomplianceOfDirections, processFurtherEvidence); + + public static final List REVIEW_TASKS_TO_COMPLETE = Stream + .of(TaskType.values()) + .filter(taskType -> taskType.name().startsWith("review") + && !taskType.name().startsWith("reviewSpecificAccess") + && taskType != reviewOrder) + .toList(); + + private TaskTypeCollections() { + } +} diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/Authorisations.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/Authorisations.java new file mode 100644 index 0000000000..ada71e49c3 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/Authorisations.java @@ -0,0 +1,19 @@ +package uk.gov.hmcts.sptribs.taskmanagement.model; + +import lombok.Getter; + +@Getter +public enum Authorisations { + JUDICIAL("328"), + NONE(""); + + private final String authorisation; + + Authorisations(String authorisation) { + this.authorisation = authorisation; + } +} + + + + diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/ProcessCategoryIdentifiers.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/ProcessCategoryIdentifiers.java new file mode 100644 index 0000000000..bf2de74928 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/ProcessCategoryIdentifiers.java @@ -0,0 +1,17 @@ +package uk.gov.hmcts.sptribs.taskmanagement.model; + +public enum ProcessCategoryIdentifiers { + Processing, + Hearing, + Decision, + Amendment, + Application, + IssueCase, + HearingCompletion, + HearingBundle, + None +} + + + + diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/RoleCategory.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/RoleCategory.java new file mode 100644 index 0000000000..a2ef9fe31c --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/RoleCategory.java @@ -0,0 +1,17 @@ +package uk.gov.hmcts.sptribs.taskmanagement.model; + +public enum RoleCategory { + JUDICIAL, + ADMIN, + CTSC, + LEGAL_OPERATIONS, + NONE; + + public String getName() { + return this != NONE ? this.name() : null; + } +} + + + + diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskAccess.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskAccess.java new file mode 100644 index 0000000000..157deb80d7 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskAccess.java @@ -0,0 +1,134 @@ +package uk.gov.hmcts.sptribs.taskmanagement.model; + +import lombok.Getter; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.TaskPermission; + +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Set; + +import static uk.gov.hmcts.sptribs.taskmanagement.model.RoleCategory.ADMIN; +import static uk.gov.hmcts.sptribs.taskmanagement.model.RoleCategory.JUDICIAL; +import static uk.gov.hmcts.sptribs.taskmanagement.model.RoleCategory.LEGAL_OPERATIONS; +import static uk.gov.hmcts.sptribs.taskmanagement.model.RoleCategory.NONE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Assign; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Cancel; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Claim; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Complete; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Execute; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Manage; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Own; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Read; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Unassign; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.Unclaim; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskOperation.UnclaimAssign; + +@Getter +public enum TaskAccess { + TASK_SUPERVISOR( + Set.of(Read,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete), + NONE, false, null, + Authorisations.NONE), + REGIONAL_CENTRE_ADMIN( + Set.of(Read,Own,Claim,Unclaim,Manage,Complete), ADMIN, + false, 1, + Authorisations.NONE), + REGIONAL_CENTRE_TEAM_LEADER( + Set.of(Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete), + ADMIN, false, 2, + Authorisations.NONE), + REGIONAL_CENTRE_TEAM_LEADER_SPECIFIC_ACCESS( + Set.of(Read,Own,Claim,Manage,Assign,Unassign,Complete,Cancel), + ADMIN, false,1, + Authorisations.NONE), + HEARING_CENTRE_ADMIN( + Set.of(Read,Own,Claim,Unclaim,Manage,Complete), + ADMIN, false,1, + Authorisations.NONE), + HEARING_CENTRE_TEAM_LEADER( + Set.of(Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete), + ADMIN, false, 2, + Authorisations.NONE), + HEARING_CENTRE_TEAM_LEADER_SPECIFIC_ACCESS( + Set.of(Read,Own,Claim,Manage,Assign,Unassign,Complete,Cancel), + ADMIN, false,1, + Authorisations.NONE), + SENIOR_TRIBUNAL_CASEWORKER( + Set.of(Read,Own,Claim,Manage,Assign,Unassign,Complete,Cancel), + LEGAL_OPERATIONS, false, 1, + Authorisations.NONE), + TRIBUNAL_CASEWORKER( + Set.of(Read,Own,Claim,Assign,Unassign,Complete,Cancel), + LEGAL_OPERATIONS, false, 2, + Authorisations.NONE), + SENIOR_JUDGE( + Set.of(Read,Execute,Claim,Manage,Assign,Unassign,Complete,Cancel), + JUDICIAL, + false, 1, + Authorisations.JUDICIAL), + JUDGE( + Set.of(Read,Own,Claim,Assign,Unassign,Complete,Cancel), + JUDICIAL, false, 2, + Authorisations.JUDICIAL), + LEADERSHIP_JUDGE( + Set.of(Read,Own,Claim,Manage,Assign,Unassign,Complete,Cancel), + JUDICIAL, false, 1, + Authorisations.JUDICIAL), + CTSC( + Set.of(Read,Own,Claim,Unclaim,Manage,Complete), + RoleCategory.CTSC, false, 1, + Authorisations.NONE), + CTSC_TEAM_LEADER( + Set.of(Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete), + RoleCategory.CTSC, false, 2, + Authorisations.NONE), + CTSC_TEAM_LEADER_SPECIFIC_ACCESS( + Set.of(Read,Own,Claim,Manage,Assign,Unassign,Complete,Cancel), + RoleCategory.CTSC, false, 1, + Authorisations.NONE); + + private final Set permissions; + private final RoleCategory roleCategory; + private final boolean autoAssignable; + private final Integer assignmentPriority; + private final Authorisations authorisations; + + TaskAccess( + Set permissions, + RoleCategory roleCategory, + boolean autoAssignable, + Integer assignmentPriority, + Authorisations authorisations + ) { + this.permissions = permissions; + this.roleCategory = roleCategory; + this.autoAssignable = autoAssignable; + this.assignmentPriority = assignmentPriority; + this.authorisations = authorisations; + } + + public TaskPermission toTaskPermission() { + String roleName = name() + .toLowerCase() + .replace("_specific_access", "") + .replace('_', '-'); + List authorisationsList = authorisations == Authorisations.NONE + ? Collections.emptyList() + : List.of(authorisations.getAuthorisation()); + + return TaskPermission.builder() + .roleName(roleName) + .roleCategory(roleCategory.getName()) + .permissions(permissions.stream() + .sorted(Comparator.comparingInt(Enum::ordinal)) + .map(TaskOperation::name) + .toList()) + .authorisations(authorisationsList) + .assignmentPriority(assignmentPriority) + .autoAssignable(autoAssignable) + .build(); + } +} + + diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskOperation.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskOperation.java new file mode 100644 index 0000000000..da4fa4d760 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskOperation.java @@ -0,0 +1,19 @@ +package uk.gov.hmcts.sptribs.taskmanagement.model; + +public enum TaskOperation { + Read, + Execute, + Own, + Claim, + Unclaim, + Manage, + UnclaimAssign, + Assign, + Unassign, + Complete, + Cancel +} + + + + diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskType.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskType.java new file mode 100644 index 0000000000..dd70d2d354 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/TaskType.java @@ -0,0 +1,294 @@ +package uk.gov.hmcts.sptribs.taskmanagement.model; + +import lombok.Getter; + +import java.util.List; +import java.util.stream.Stream; + +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.COMPLETE_HEARING_OUTCOME_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.CREATE_DUE_DATE_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.EMPTY_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.FOLLOW_UP_NONCOMPLIANCE_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.ISSUE_CASE_TO_RESPONDENT_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.ISSUE_DECISION_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.PROCESS_FURTHER_EVIDENCE_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.REGISTER_NEW_CASE_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.REVIEW_REQUESTS_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.SEND_ORDER_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.STITCH_COLLATE_BUNDLE_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskConstants.VET_NEW_CASE_DOCUMENTS_DESCRIPTION; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.Amendment; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.Application; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.Decision; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.Hearing; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.HearingBundle; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.HearingCompletion; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.IssueCase; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.None; +import static uk.gov.hmcts.sptribs.taskmanagement.model.ProcessCategoryIdentifiers.Processing; + +@Getter +public enum TaskType { + processCaseWithdrawalDirections("Process case withdrawal directions", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processCaseWithdrawalDirectionsListed( + "Process case withdrawal directions listed", + Processing, + 7, + SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processRule27Decision("Process Rule 27 decision", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processRule27DecisionListed("Process Rule 27 decision listed", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processListingDirections("Process listing directions", Processing, 3, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processListingDirectionsListed("Process listing directions listed", Processing, 3, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processDirectionsReListedCase("Process directions re. listed case", Hearing, 1, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processDirectionsReListedCaseWithin5Days( + "Process directions re. listed case (within 5 days)", + Hearing, + 1, + SEND_ORDER_DESCRIPTION, + WorkType.PRIORITY.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processSetAsideDirections("Process set aside directions", Decision, 1, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processCorrections("Process corrections", Amendment, 3, SEND_ORDER_DESCRIPTION, + WorkType.HEARING_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processDirectionsReturned("Process directions returned", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processPostponementDirections("Process postponement directions", Hearing, 1, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processTimeExtensionDirectionsReturned( + "Process time extension directions returned", + Processing, + 1, + SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processReinstatementDecisionNotice("Process reinstatement decision notice", Application, 5, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processOtherDirectionsReturned("Process other directions returned", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processWrittenReasons("Process written reasons", Decision, 3, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processStrikeOutDirectionsReturned("Process strike out directions returned", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processStayDirections("Process stay directions", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processStayDirectionsListed("Process stay directions listed", Processing, 7, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + issueDecisionNotice("Issue decision notice", None, 1, ISSUE_DECISION_DESCRIPTION, + WorkType.HEARING_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + completeHearingOutcome("Complete hearing outcome", HearingCompletion, 5, COMPLETE_HEARING_OUTCOME_DESCRIPTION, + WorkType.HEARING_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + issueCaseToRespondent("Issue case to respondent", IssueCase, 2, ISSUE_CASE_TO_RESPONDENT_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + vetNewCaseDocuments("Vet new case documents", None, 5, VET_NEW_CASE_DOCUMENTS_DESCRIPTION, + WorkType.APPLICATIONS.getLowerCaseName(), + RoleCategory.ADMIN.name()), + reviewNewCaseAndProvideDirectionsLO("Review new case and provide directions - Legal Officer", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewTimeExtensionRequestLO("Review time extension request - Legal Officer", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewStrikeOutRequestLO("Review strike out request - Legal Officer", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewStayRequestLO("Review stay request - Legal Officer", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewStayRequestCaseListedLO("Review stay request case listed - Legal Officer", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewListingDirectionsLO("Review listing directions - Legal Officer", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewListingDirectionsCaseListedLO("Review listing directions case listed - Legal Officer", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewWithdrawalRequestLO("Review withdrawal request - Legal Officer", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewWithdrawalRequestCaseListedLO("Review withdrawal request case listed - Legal Officer", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewRule27RequestLO("Review Rule 27 request - Legal Officer", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewRule27RequestCaseListedLO("Review Rule 27 request case listed - Legal Officer", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewListCaseLO("Review list case - Legal Officer", Hearing, 1, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewOtherRequestLO("Review other request - Legal Officer", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewListCaseWithin5DaysLO("Review list case (within 5 days) - Legal Officer", Hearing, 1, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewPostponementRequestLO("Review postponement request - Legal Officer", Hearing, 1, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewReinstatementRequestLO("Review reinstatement request - Legal Officer", Application, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.LEGAL_OPERATIONS.name()), + reviewListCaseWithin5DaysJudge("Review list case (within 5 days) - Judge", Hearing, 1, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewPostponementRequestJudge("Review postponement request - Judge", Hearing, 1, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewCorrectionsRequest("Review corrections request", Amendment, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewWrittenReasonsRequest("Review written reasons request", Decision, 28, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewReinstatementRequestJudge( + "Review reinstatement request - Judge", + Application, + 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewSetAsideRequest("Review set aside request", Decision, 2, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewStayRequestJudge("Review stay request - Judge", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewStayRequestCaseListedJudge("Review stay request case listed - Judge", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewNewCaseAndProvideDirectionsJudge("Review new case and provide directions - Judge", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewOtherRequestJudge("Review other request - Judge", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewWithdrawalRequestJudge("Review withdrawal request - Judge", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewWithdrawalRequestCaseListedJudge("Review withdrawal request case listed - Judge", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewRule27RequestJudge("Review Rule 27 request - Judge", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewRule27RequestCaseListedJudge("Review Rule 27 request case listed - Judge", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewListingDirectionsJudge("Review listing directions - Judge", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewListingDirectionsCaseListedJudge("Review listing directions case listed - Judge", Processing, 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewListCaseJudge("Review list case - Judge", Hearing, 1, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewStrikeOutRequestJudge("Review strike out request - Judge", Processing, 5, REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + reviewTimeExtensionRequestJudge( + "Review time extension request - Judge", + Processing, + 5, + REVIEW_REQUESTS_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.JUDICIAL.name()), + followUpNoncomplianceOfDirections("Follow up noncompliance of directions", Processing, 1, + FOLLOW_UP_NONCOMPLIANCE_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + registerNewCase("Register new case", None, 5, REGISTER_NEW_CASE_DESCRIPTION, + WorkType.APPLICATIONS.getLowerCaseName(), + RoleCategory.ADMIN.name()), + processFurtherEvidence("Process further evidence", Processing, 7, PROCESS_FURTHER_EVIDENCE_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + stitchCollateHearingBundle("Stitch/collate hearing bundle", HearingBundle, 1, STITCH_COLLATE_BUNDLE_DESCRIPTION, + WorkType.HEARING_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + createDueDate("Create due date", IssueCase, 2, CREATE_DUE_DATE_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + issueDueDate("Issue due date", IssueCase, 2, SEND_ORDER_DESCRIPTION, + WorkType.ROUTINE_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()), + reviewOrder("Review Order", Decision, 5, EMPTY_DESCRIPTION, + WorkType.DECISION_MAKING_WORK.getLowerCaseName(), + RoleCategory.ADMIN.name()); + + private final String name; + private final ProcessCategoryIdentifiers processCategoryIdentifier; + /*dueDateIntervalDays is not always an intrinsic prop of the task as it is set in the initiation dmn, + just happens to be the case for sp tribs*/ + private final int dueDateIntervalDays; + private final String description; + private final String workType; + private final String roleCategory; + + TaskType( + String name, + ProcessCategoryIdentifiers processCategoryIdentifier, + int dueDateIntervalDays, + String description, + String workType, + String roleCategory + ) { + this.name = name; + this.processCategoryIdentifier = processCategoryIdentifier; + this.dueDateIntervalDays = dueDateIntervalDays; + this.description = description; + this.workType = workType; + this.roleCategory = roleCategory; + } + + public static List getTaskTypesFromProcessCategoryIdentifiers( + List processCategoryIdentifiers + ) { + return Stream.of(TaskType.values()) + .filter(taskType -> processCategoryIdentifiers.contains(taskType.getProcessCategoryIdentifier())) + .toList(); + } +} diff --git a/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/WorkType.java b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/WorkType.java new file mode 100644 index 0000000000..5033a50cc9 --- /dev/null +++ b/src/main/java/uk/gov/hmcts/sptribs/taskmanagement/model/WorkType.java @@ -0,0 +1,17 @@ +package uk.gov.hmcts.sptribs.taskmanagement.model; + +public enum WorkType { + ROUTINE_WORK, + PRIORITY, + HEARING_WORK, + DECISION_MAKING_WORK, + APPLICATIONS; + + public String getLowerCaseName() { + return name().toLowerCase(); + } +} + + + + diff --git a/src/main/resources/application.yaml b/src/main/resources/application.yaml index 78d30adfa7..871a179f71 100644 --- a/src/main/resources/application.yaml +++ b/src/main/resources/application.yaml @@ -249,3 +249,6 @@ wa_task_monitor_api: url: ${TASK_MONITOR_API_URL:http://wa-task-monitor-aat.service.core-compute-aat.internal} wa_task_management_api: url: ${TASK_MANAGEMENT_API_URL:http://wa-task-management-api-aat.service.core-compute-aat.internal} +task-management: + api: + url: ${TASK_MANAGEMENT_API_URL:http://wa-task-management-api-aat.service.core-compute-aat.internal} diff --git a/src/main/resources/cftlib-am-role-assignments.json b/src/main/resources/cftlib-am-role-assignments.json index 567e714e7d..9a51b30d03 100644 --- a/src/main/resources/cftlib-am-role-assignments.json +++ b/src/main/resources/cftlib-am-role-assignments.json @@ -67,6 +67,180 @@ "jurisdiction": "ST_CIC" }, "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "regional-centre-admin", + "grantType": "STANDARD", + "roleCategory": "ADMIN", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "regional-centre-team-leader", + "grantType": "STANDARD", + "roleCategory": "ADMIN", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "hearing-centre-admin", + "grantType": "STANDARD", + "roleCategory": "ADMIN", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "hearing-centre-team-leader", + "grantType": "STANDARD", + "roleCategory": "ADMIN", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "senior-tribunal-caseworker", + "grantType": "STANDARD", + "roleCategory": "LEGAL_OPERATIONS", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "tribunal-caseworker", + "grantType": "STANDARD", + "roleCategory": "LEGAL_OPERATIONS", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "senior-judge", + "grantType": "STANDARD", + "roleCategory": "JUDICIAL", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [ + "328" + ] + }, + { + "roleType": "ORGANISATION", + "roleName": "judge", + "grantType": "STANDARD", + "roleCategory": "JUDICIAL", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [ + "328" + ] + }, + { + "roleType": "ORGANISATION", + "roleName": "ctsc", + "grantType": "STANDARD", + "roleCategory": "CTSC", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] + }, + { + "roleType": "ORGANISATION", + "roleName": "ctsc-team-leader", + "grantType": "STANDARD", + "roleCategory": "CTSC", + "classification": "PUBLIC", + "readOnly": false, + "attributes": { + "jurisdiction": "ST_CIC", + "caseType": "CriminalInjuriesCompensation", + "region": "11", + "baseLocation": "366559", + "substantive": "Y", + "bookable": true + }, + "authorisations": [] } ], "overrideAll": true diff --git a/src/main/resources/dmn/wa-task-cancellation-st_cic-criminalinjuriescompensation.dmn b/src/main/resources/dmn/wa-task-cancellation-st_cic-criminalinjuriescompensation.dmn deleted file mode 100644 index 602d155b94..0000000000 --- a/src/main/resources/dmn/wa-task-cancellation-st_cic-criminalinjuriescompensation.dmn +++ /dev/null @@ -1,127 +0,0 @@ - - - - - - - fromState - - - - - event - - - - - state - - - - - - - - - - - - - "caseworker-close-the-case" - - - - - - "Cancel" - - - - - - - - - - - - - - - - - "refer-to-judge","refer-to-legal-officer" - - - - - - "Cancel" - - - - - - - - - "IssueCase" - - - - - - - - - "caseworker-postpone-hearing","caseworker-cancel-hearing" - - - - - - "Cancel" - - - - - - - - - "HearingCompletion" - - - - - - - - "caseworker-postpone-hearing","caseworker-cancel-hearing" - - - - - - "Cancel" - - - - - - - - - "HearingBundle" - - - - - - - - - - - - diff --git a/src/main/resources/dmn/wa-task-configuration-st_cic-criminalinjuriescompensation.dmn b/src/main/resources/dmn/wa-task-configuration-st_cic-criminalinjuriescompensation.dmn index 5778f705a1..cf7545e8bf 100644 --- a/src/main/resources/dmn/wa-task-configuration-st_cic-criminalinjuriescompensation.dmn +++ b/src/main/resources/dmn/wa-task-configuration-st_cic-criminalinjuriescompensation.dmn @@ -1,5 +1,5 @@ - + @@ -114,7 +114,7 @@ Short name - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processListingDirectionsListed","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processPostponementDirections","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","reviewNewCaseAndProvideDirectionsLO","reviewTimeExtensionRequestLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","reviewListCaseLO","vetNewCaseDocuments","reviewOtherRequestLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewReinstatementRequestLO","reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewCorrectionsRequest","reviewWrittenReasonsRequest","reviewReinstatementRequestJudge","reviewSetAsideRequest","reviewStayRequestJudge","reviewNewCaseAndProvideDirectionsJudge","reviewOtherRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewListingDirectionsJudge","reviewListingDirectionsCaseListedJudge","reviewListCaseJudge","reviewStrikeOutRequestJudge","reviewTimeExtensionRequestJudge","reviewSpecificAccessRequestJudiciary","reviewSpecificAccessRequestLegalOps","reviewSpecificAccessRequestAdmin","reviewSpecificAccessRequestCTSC","followUpNoncomplianceOfDirections","registerNewCase","processFurtherEvidence","stitchCollateHearingBundle","createDueDate","issueDueDate","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO","reviewWithdrawalRequestCaseListedJudge","processCaseWithdrawalDirectionsListed","reviewStayRequestCaseListedJudge","processStayDirectionsListed","reviewRule27RequestCaseListedJudge","processRule27DecisionListed","reviewOrder" + "reviewSpecificAccessRequestJudiciary","reviewSpecificAccessRequestLegalOps","reviewSpecificAccessRequestAdmin","reviewSpecificAccessRequestCTSC" "majorPriority" @@ -133,7 +133,7 @@ else 5000 - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processListingDirectionsListed","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processPostponementDirections","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","reviewNewCaseAndProvideDirectionsLO","reviewTimeExtensionRequestLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","reviewListCaseLO","vetNewCaseDocuments","reviewOtherRequestLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewReinstatementRequestLO","reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewCorrectionsRequest","reviewWrittenReasonsRequest","reviewReinstatementRequestJudge","reviewSetAsideRequest","reviewStayRequestJudge","reviewNewCaseAndProvideDirectionsJudge","reviewOtherRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewListingDirectionsJudge","reviewListingDirectionsCaseListedJudge","reviewListCaseJudge","reviewStrikeOutRequestJudge","reviewTimeExtensionRequestJudge","reviewSpecificAccessRequestJudiciary","reviewSpecificAccessRequestLegalOps","reviewSpecificAccessRequestAdmin","reviewSpecificAccessRequestCTSC","followUpNoncomplianceOfDirections","registerNewCase","processFurtherEvidence","stitchCollateHearingBundle","createDueDate","issueDueDate","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO","reviewWithdrawalRequestCaseListedJudge","processCaseWithdrawalDirectionsListed","reviewStayRequestCaseListedJudge","processStayDirectionsListed","reviewRule27RequestCaseListedJudge","processRule27DecisionListed","reviewOrder" + "reviewSpecificAccessRequestJudiciary","reviewSpecificAccessRequestLegalOps","reviewSpecificAccessRequestAdmin","reviewSpecificAccessRequestCTSC" "minorPriority" @@ -179,91 +179,6 @@ else 5000 false - - - - - - "processOtherDirectionsReturned","processRule27Decision","processCaseWithdrawalDirections","processListingDirections","processListingDirectionsListed","processDirectionsReListedCase","processStrikeOutDirectionsReturned","processStayDirections","issueCaseToRespondent","followUpNoncomplianceOfDirections","processFurtherEvidence","processSetAsideDirections","processDirectionsReturned","processPostponementDirections","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processWrittenReasons","createDueDate","issueDueDate","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed" - - - "workType" - - - "routine_work" - - - true - - - - - - - - "processDirectionsReListedCaseWithin5Days" - - - "workType" - - - "priority" - - - true - - - - - - - - "reviewNewCaseAndProvideDirectionsLO","reviewTimeExtensionRequestLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","reviewListCaseLO","reviewOtherRequestLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewReinstatementRequestLO","reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewCorrectionsRequest","reviewWrittenReasonsRequest","reviewReinstatementRequestJudge","reviewSetAsideRequest","reviewStayRequestJudge","reviewNewCaseAndProvideDirectionsJudge","reviewOtherRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewListingDirectionsJudge","reviewListingDirectionsCaseListedJudge","reviewListCaseJudge","reviewStrikeOutRequestJudge","reviewTimeExtensionRequestJudge","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO","reviewWithdrawalRequestCaseListedJudge","reviewStayRequestCaseListedJudge","reviewRule27RequestCaseListedJudge","reviewOrder" - - - "workType" - - - "decision_making_work" - - - true - - - - - - - - "issueDecisionNotice","completeHearingOutcome","stitchCollateHearingBundle","processCorrections" - - - "workType" - - - "hearing_work" - - - true - - - - - - - - "vetNewCaseDocuments","registerNewCase" - - - "workType" - - - "applications" - - - true - - @@ -286,7 +201,7 @@ else 5000 - "processRule27Decision","processCaseWithdrawalDirections","processListingDirections","processListingDirectionsListed","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processPostponementDirections","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","vetNewCaseDocuments","reviewSpecificAccessRequestAdmin","followUpNoncomplianceOfDirections","registerNewCase","processFurtherEvidence","stitchCollateHearingBundle","createDueDate","issueDueDate","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed","reviewOrder" + "reviewSpecificAccessRequestAdmin" "roleCategory" @@ -303,7 +218,7 @@ else 5000 - "reviewNewCaseAndProvideDirectionsLO","reviewTimeExtensionRequestLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","reviewListCaseLO","reviewOtherRequestLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewReinstatementRequestLO","reviewSpecificAccessRequestLegalOps","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO" + "reviewSpecificAccessRequestLegalOps" "roleCategory" @@ -320,7 +235,7 @@ else 5000 - "reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewCorrectionsRequest","reviewWrittenReasonsRequest","reviewReinstatementRequestJudge","reviewSetAsideRequest","reviewStayRequestJudge","reviewNewCaseAndProvideDirectionsJudge","reviewOtherRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewListingDirectionsJudge","reviewListingDirectionsCaseListedJudge","reviewListCaseJudge","reviewStrikeOutRequestJudge","reviewTimeExtensionRequestJudge","reviewSpecificAccessRequestJudiciary","reviewWithdrawalRequestCaseListedJudge","reviewStayRequestCaseListedJudge","reviewRule27RequestCaseListedJudge" + "reviewSpecificAccessRequestJudiciary" "roleCategory" @@ -349,29 +264,12 @@ else 5000 true - - - - - - "processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processPostponementDirections","processTimeExtensionDirectionsReturned","issueDecisionNotice","reviewListCaseLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewListCaseJudge","followUpNoncomplianceOfDirections","stitchCollateHearingBundle" - - - "dueDateIntervalDays" - - - 1 - - - true - - - "issueCaseToRespondent","reviewSetAsideRequest","reviewSpecificAccessRequestJudiciary","reviewSpecificAccessRequestLegalOps","reviewSpecificAccessRequestAdmin","reviewSpecificAccessRequestCTSC","createDueDate","issueDueDate" + "reviewSpecificAccessRequestJudiciary","reviewSpecificAccessRequestLegalOps","reviewSpecificAccessRequestAdmin","reviewSpecificAccessRequestCTSC" "dueDateIntervalDays" @@ -383,278 +281,6 @@ else 5000 true - - - - - - "processCorrections","processWrittenReasons","processListingDirections","processListingDirectionsListed" - - - "dueDateIntervalDays" - - - 3 - - - true - - - - - - - - "processReinstatementDecisionNotice","completeHearingOutcome","reviewNewCaseAndProvideDirectionsLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","vetNewCaseDocuments","reviewOtherRequestLO","reviewReinstatementRequestLO","registerNewCase","reviewNewCaseAndProvideDirectionsJudge","reviewStrikeOutRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewStayRequestJudge","reviewListingDirectionsJudge","reviewListingDirectionsCaseListedJudge","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewCorrectionsRequest","reviewReinstatementRequestJudge","reviewOtherRequestJudge","reviewTimeExtensionRequestLO","reviewTimeExtensionRequestJudge","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO","reviewWithdrawalRequestCaseListedJudge","reviewStayRequestCaseListedJudge","reviewRule27RequestCaseListedJudge","reviewOrder" - - - "dueDateIntervalDays" - - - 5 - - - true - - - - - - - - "processDirectionsReturned","processFurtherEvidence","processStrikeOutDirectionsReturned","processCaseWithdrawalDirections","processRule27Decision","processStayDirections","processOtherDirectionsReturned","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed" - - - "dueDateIntervalDays" - - - 7 - - - true - - - - - - - - "reviewWrittenReasonsRequest" - - - "dueDateIntervalDays" - - - 28 - - - true - - - - - - - - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processListingDirectionsListed","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processPostponementDirections","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDueDate","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed" - - - "description" - - - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-send-order)" - - - true - - - - - - - - "issueDecisionNotice" - - - "description" - - - "[Decision: Issue a decision](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-issue-decision)<br/>" + "[Decision: Issue final decision](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-issue-final-decision)" - - - true - - - - - - - - "completeHearingOutcome" - - - "description" - - - "[Hearings:Create summary](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-hearing-summary)" - - - true - - - - - - - - "issueCaseToRespondent" - - - "description" - - - "[Case: Issue to respondent](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-issue-case)" - - - true - - - - - - - - "vetNewCaseDocuments" - - - "description" - - - "[Case: Build case](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-case-built)" - - - true - - - - - - - - "createDueDate" - - - "description" - - - "[Orders: Create draft](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-draft-order)" - - - true - - - - - - - - "reviewNewCaseAndProvideDirectionsLO","reviewTimeExtensionRequestLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","reviewListCaseLO","reviewOtherRequestLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewReinstatementRequestLO","reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewCorrectionsRequest","reviewWrittenReasonsRequest","reviewReinstatementRequestJudge","reviewSetAsideRequest","reviewStayRequestJudge","reviewNewCaseAndProvideDirectionsJudge","reviewOtherRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewListingDirectionsJudge","reviewListingDirectionsCaseListedJudge","reviewListCaseJudge","reviewStrikeOutRequestJudge","reviewTimeExtensionRequestJudge","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO","reviewWithdrawalRequestCaseListedJudge","reviewStayRequestCaseListedJudge","reviewRule27RequestCaseListedJudge" - - - "description" - - - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)" - - - true - - - - - - - - "followUpNoncomplianceOfDirections" - - - "description" - - - "[Document management: Upload](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-document-management)<br/>" + "[Orders: Manage due date](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-amend-due-date)<br/>" + "[Refer case to judge](/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-judge)<br/>" + "[Refer case to legal officer](/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-legal-officer)<br/>" + "[Case: Contact parties](/cases/case-details/${[CASE_REFERENCE]}/trigger/contact-parties)" - - - true - - - - - - - - "registerNewCase" - - - "description" - - - "[Case: Edit case](/cases/case-details/${[CASE_REFERENCE]}/trigger/edit-case)" - - - true - - - - - - - - "stitchCollateHearingBundle" - - - "description" - - - "[Bundle: Create a bundle](/cases/case-details/${[CASE_REFERENCE]}/trigger/createBundle)" - - - true - - - - - - - - "processFurtherEvidence" - - - "description" - - - "[Document management: Amend](/cases/case-details/${[CASE_REFERENCE]}/trigger/caseworker-amend-document)<br/>" + "[Case: Edit case](/cases/case-details/${[CASE_REFERENCE]}/trigger/edit-case)<br/>" + "[Refer case to judge](/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-judge)<br/>" + "[Refer case to legal officer](/cases/case-details/${[CASE_REFERENCE]}/trigger/refer-to-legal-officer)<br/>" + "[Case: Contact parties](/cases/case-details/${[CASE_REFERENCE]}/trigger/contact-parties)" - - - true - - - - - - - - "reviewOrder" - - - "description" - - - "" - - - true - - diff --git a/src/main/resources/dmn/wa-task-initiation-st_cic-criminalinjuriescompensation.dmn b/src/main/resources/dmn/wa-task-initiation-st_cic-criminalinjuriescompensation.dmn deleted file mode 100644 index 834739c961..0000000000 --- a/src/main/resources/dmn/wa-task-initiation-st_cic-criminalinjuriescompensation.dmn +++ /dev/null @@ -1,2534 +0,0 @@ - - - - - - - - - - - - - - - - - if(additionalData != null and additionalData.Data != null and additionalData.Data.cicCaseReferralTypeForWA - != null) then - additionalData.Data.cicCaseReferralTypeForWA - else - null - - - - - if(additionalData != null and additionalData.Data != null and additionalData.Data.cicCaseAdminActionRequired - != null and additionalData.Data.cicCaseAdminActionRequired = ["AdminActionRequired"]) then - true -else - false - - - - - if(additionalData.Data.cicCaseFirstOrderDueDate != null and additionalData.Data.cicCaseFirstOrderDueDate != "") then - true -else - false - - - - - - - - - - - - "create-draft-order" - - - "CaseManagement", "ReadyToList" - - - "Withdrawal request" - - - - - - - - - "processCaseWithdrawalDirections" - - - "Process case withdrawal directions" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "AwaitingHearing" - - - "Withdrawal request" - - - - - - - - - "processCaseWithdrawalDirectionsListed" - - - "Process case withdrawal directions listed" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseManagement", "ReadyToList" - - - "Rule 27 request" - - - - - - - - - "processRule27Decision" - - - "Process Rule 27 decision" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "AwaitingHearing" - - - "Rule 27 request" - - - - - - - - - "processRule27DecisionListed" - - - "Process Rule 27 decision listed" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseManagement" - - - "Listing directions" - - - - - - - - - "processListingDirections" - - - "Process listing directions" - - - - - - 3 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "ReadyToList" - - - "Listing directions" - - - - - - - - - "processListingDirectionsListed" - - - "Process listing directions listed" - - - - - - 3 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "AwaitingHearing" - - - "Listed case" - - - - - - - - - "processDirectionsReListedCase" - - - "Process directions re. listed case" - - - - - - 1 - - - "Hearing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "AwaitingHearing" - - - "Listed case (within 5 days)" - - - - - - - - - "processDirectionsReListedCaseWithin5Days" - - - "Process directions re. listed case (within 5 days)" - - - - - - 1 - - - "Hearing" - - - "priority" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseClosed" - - - "Set aside request" - - - - - - - - - "processSetAsideDirections" - - - "Process set aside directions" - - - - - - 1 - - - "Decision" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseClosed" - - - "Corrections" - - - - - - - - - "processCorrections" - - - "Process corrections" - - - - - - 3 - - - "Amendment" - - - "hearing_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseManagement", "ReadyToList" - - - "New case" - - - - - - - - - "processDirectionsReturned" - - - "Process directions returned" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "AwaitingHearing" - - - "Postponement request" - - - - - - - - - "processPostponementDirections" - - - "Process postponement directions" - - - - - - 1 - - - "Hearing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseManagement", "ReadyToList" - - - "Time extension request" - - - - - - - - - "processTimeExtensionDirectionsReturned" - - - "Process time extension directions returned" - - - - - - 1 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseClosed" - - - "Reinstatement request" - - - - - - - - - "processReinstatementDecisionNotice" - - - "Process reinstatement decision notice" - - - - - - 5 - - - "Application" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - - - - "Other" - - - - - - - - - "processOtherDirectionsReturned" - - - "Process other directions returned" - - - - - - 7 - - - "Processing" - - - "decision_making_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseClosed" - - - "Written reasons request" - - - - - - - - - "processWrittenReasons" - - - "Process written reasons" - - - - - - 3 - - - "Decision" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseManagement", "ReadyToList" - - - "Strike out request" - - - - - - - - - "processStrikeOutDirectionsReturned" - - - "Process strike out directions returned" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseManagement", "ReadyToList" - - - "Stay request" - - - - - - - - - "processStayDirections" - - - "Process stay directions" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "CaseManagement" - - - "" - - - - - - - - - "issueDueDate" - - - "Issue due date" - - - - - - 2 - - - "IssueCase" - - - "routine_work" - - - "ADMIN" - - - - - "create-draft-order" - - - "AwaitingHearing" - - - "Stay request" - - - - - - - - - "processStayDirectionsListed" - - - "Process stay directions listed" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "create-hearing-summary" - - - "AwaitingOutcome" - - - - - - - - - - - - "issueDecisionNotice" - - - "Issue decision notice" - - - - - - 1 - - - - - - "hearing_work" - - - "ADMIN" - - - - - "system-trigger-complete-hearing-outcome" - - - "AwaitingHearing" - - - - - - - - - - - - "completeHearingOutcome" - - - "Complete hearing outcome" - - - - - - 5 - - - "HearingCompletion" - - - "hearing_work" - - - "ADMIN" - - - - - "caseworker-case-built" - - - "CaseManagement" - - - - - - - - - - - - "issueCaseToRespondent" - - - "Issue case to respondent" - - - - - - 2 - - - "IssueCase" - - - "routine_work" - - - "ADMIN" - - - - - "edit-case" - - - "Submitted" - - - - - - - - - - - - "vetNewCaseDocuments" - - - "Vet new case documents" - - - - - - 5 - - - - - - "applications" - - - "ADMIN" - - - - - "refer-to-legal-officer" - - - "CaseManagement", "ReadyToList" - - - "New case" - - - - - - - - - "reviewNewCaseAndProvideDirectionsLO" - - - "Review new case and provide directions - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "CaseManagement", "ReadyToList" - - - "Time extension request" - - - - - - - - - "reviewTimeExtensionRequestLO" - - - "Review time extension request - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "CaseManagement", "ReadyToList" - - - "Strike out request" - - - - - - - - - "reviewStrikeOutRequestLO" - - - "Review strike out request - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "CaseManagement", "ReadyToList" - - - "Stay request" - - - - - - - - - "reviewStayRequestLO" - - - "Review stay request - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "AwaitingHearing" - - - "Stay request" - - - - - - - - - "reviewStayRequestCaseListedLO" - - - "Review stay request case listed - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "CaseManagement" - - - "Listing directions" - - - - - - - - - "reviewListingDirectionsLO" - - - "Review listing directions - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "ReadyToList" - - - "Listing directions" - - - - - - - - - "reviewListingDirectionsCaseListedLO" - - - "Review listing directions case listed - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "CaseManagement", "ReadyToList" - - - "Withdrawal request" - - - - - - - - - "reviewWithdrawalRequestLO" - - - "Review withdrawal request - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "AwaitingHearing" - - - "Withdrawal request" - - - - - - - - - "reviewWithdrawalRequestCaseListedLO" - - - "Review withdrawal request case listed - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "CaseManagement", "ReadyToList" - - - "Rule 27 request" - - - - - - - - - "reviewRule27RequestLO" - - - "Review Rule 27 request - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "AwaitingHearing" - - - "Rule 27 request" - - - - - - - - - "reviewRule27RequestCaseListedLO" - - - "Review Rule 27 request case listed - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "AwaitingHearing" - - - "Listed case" - - - - - - - - - "reviewListCaseLO" - - - "Review list case - Legal Officer" - - - - - - 1 - - - "Hearing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "AwaitingHearing" - - - "Listed case (within 5 days)" - - - - - - - - - "reviewListCaseWithin5DaysLO" - - - "Review list case (within 5 days) - Legal Officer" - - - - - - 1 - - - "Hearing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "AwaitingHearing" - - - "Postponement request" - - - - - - - - - "reviewPostponementRequestLO" - - - "Review postponement request - Legal Officer" - - - - - - 1 - - - "Hearing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - "CaseClosed" - - - "Reinstatement request" - - - - - - - - - "reviewReinstatementRequestLO" - - - "Review reinstatement request - Legal Officer" - - - - - - 5 - - - "Application" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-legal-officer" - - - - - - "Other" - - - - - - - - - "reviewOtherRequestLO" - - - "Review other request - Legal Officer" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "LEGAL_OPERATIONS" - - - - - "refer-to-judge" - - - "AwaitingHearing" - - - "Listed case (within 5 days)" - - - - - - - - - "reviewListCaseWithin5DaysJudge" - - - "Review list case (within 5 days) - Judge" - - - - - - 1 - - - "Hearing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "AwaitingHearing" - - - "Postponement request" - - - - - - - - - "reviewPostponementRequestJudge" - - - "Review postponement request - Judge" - - - - - - 1 - - - "Hearing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseClosed" - - - "Corrections" - - - - - - - - - "reviewCorrectionsRequest" - - - "Review corrections request" - - - - - - 5 - - - "Amendment" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseClosed" - - - "Written reasons request" - - - - - - - - - "reviewWrittenReasonsRequest" - - - "Review written reasons request" - - - - - - 28 - - - "Decision" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseClosed" - - - "Reinstatement request" - - - - - - - - - "reviewReinstatementRequestJudge" - - - "Review reinstatement request - Judge" - - - - - - 5 - - - "Application" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseClosed" - - - "Set aside request" - - - - - - - - - "reviewSetAsideRequest" - - - "Review set aside request" - - - - - - 2 - - - "Decision" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseManagement", "ReadyToList" - - - "Stay request" - - - - - - - - - "reviewStayRequestJudge" - - - "Review stay request - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "AwaitingHearing" - - - "Stay request" - - - - - - - - - "reviewStayRequestCaseListedJudge" - - - "Review stay request case listed - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseManagement", "ReadyToList" - - - "New case" - - - - - - - - - "reviewNewCaseAndProvideDirectionsJudge" - - - "Review new case and provide directions - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - - - - "Other" - - - - - - - - - "reviewOtherRequestJudge" - - - "Review other request - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseManagement", "ReadyToList" - - - "Withdrawal request" - - - - - - - - - "reviewWithdrawalRequestJudge" - - - "Review withdrawal request - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "AwaitingHearing" - - - "Withdrawal request" - - - - - - - - - "reviewWithdrawalRequestCaseListedJudge" - - - "Review withdrawal request case listed - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseManagement", "ReadyToList" - - - "Rule 27 request" - - - - - - - - - "reviewRule27RequestJudge" - - - "Review Rule 27 request - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "AwaitingHearing" - - - "Rule 27 request" - - - - - - - - - "reviewRule27RequestCaseListedJudge" - - - "Review Rule 27 request case listed - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseManagement" - - - "Listing directions" - - - - - - - - - "reviewListingDirectionsJudge" - - - "Review listing directions - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "ReadyToList" - - - "Listing directions" - - - - - - - - - "reviewListingDirectionsCaseListedJudge" - - - "Review listing directions case listed - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "AwaitingHearing" - - - "Listed case" - - - - - - - - - "reviewListCaseJudge" - - - "Review list case - Judge" - - - - - - 1 - - - "Hearing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseManagement", "ReadyToList" - - - "Strike out request" - - - - - - - - - "reviewStrikeOutRequestJudge" - - - "Review strike out request - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "refer-to-judge" - - - "CaseManagement", "ReadyToList" - - - "Time extension request" - - - - - - - - - "reviewTimeExtensionRequestJudge" - - - "Review time extension request - Judge" - - - - - - 5 - - - "Processing" - - - "decision_making_work" - - - "JUDICIAL" - - - - - "caseworker-send-order", "create-and-send-order" - - - "CaseManagement" - - - - - - - - - true - - - "followUpNoncomplianceOfDirections" - - - "Follow up noncompliance of directions" - - - { - "delayUntilOrigin": date(additionalData.Data.cicCaseFirstOrderDueDate), - "delayUntilIntervalDays": 1, - "delayUntilNonWorkingCalendar": "https://www.gov.uk/bank-holidays/scotland.json, https://raw.githubusercontent.com/hmcts/sptribs-case-api/master/src/main/resources/dmn/privilege-calendar.json", - "delayUntilNonWorkingDaysOfWeek": "SATURDAY,SUNDAY", - "delayUntilSkipNonWorkingDays": false, - "delayUntilMustBeWorkingDay": "Next" -} - - - 1 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "citizen-cic-submit-dss-application" - - - "DSS_Submitted" - - - - - - - - - - - - "registerNewCase" - - - "Register new case" - - - - - - 5 - - - - - - "applications" - - - "ADMIN" - - - - - "citizen-cic-dss-update-case","caseworker-document-management","respondent-document-management" - - - - - - - - - - - - - - - "processFurtherEvidence" - - - "Process further evidence" - - - - - - 7 - - - "Processing" - - - "routine_work" - - - "ADMIN" - - - - - "system-trigger-stitch-collate-hearing-bundle" - - - "AwaitingHearing" - - - - - - - - - - - - "stitchCollateHearingBundle" - - - "Stitch/collate hearing bundle" - - - - - - 1 - - - "HearingBundle" - - - "hearing_work" - - - "ADMIN" - - - - - "caseworker-issue-case" - - - "CaseManagement" - - - - - - - - - - - - "createDueDate" - - - "Create due date" - - - - - - 2 - - - "IssueCase" - - - "routine_work" - - - "ADMIN" - - - - - "create-and-send-order" - - - - - - - - - true - - - - - - "reviewOrder" - - - "Review Order" - - - - - - 5 - - - "Decision" - - - "decision_making_work" - - - "ADMIN" - - - - - - - - - - - - diff --git a/src/main/resources/dmn/wa-task-permissions-st_cic-criminalinjuriescompensation.dmn b/src/main/resources/dmn/wa-task-permissions-st_cic-criminalinjuriescompensation.dmn index 8ca7491b79..634c7e3370 100644 --- a/src/main/resources/dmn/wa-task-permissions-st_cic-criminalinjuriescompensation.dmn +++ b/src/main/resources/dmn/wa-task-permissions-st_cic-criminalinjuriescompensation.dmn @@ -1,5 +1,5 @@ - + @@ -53,238 +53,6 @@ false - - - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","vetNewCaseDocuments","followUpNoncomplianceOfDirections","registerNewCase","stitchCollateHearingBundle","processPostponementDirections","processFurtherEvidence","createDueDate","issueDueDate","processListingDirectionsListed","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed","reviewOrder" - - - - - - - - - "regional-centre-admin" - - - "Read,Own,Claim,Unclaim,Manage,Complete" - - - "ADMIN" - - - - - - 1 - - - false - - - - - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","vetNewCaseDocuments","followUpNoncomplianceOfDirections","registerNewCase","stitchCollateHearingBundle","processPostponementDirections","processFurtherEvidence","createDueDate","issueDueDate","processListingDirectionsListed","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed","reviewOrder" - - - - - - - - - "regional-centre-team-leader" - - - "Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete" - - - "ADMIN" - - - - - - 2 - - - false - - - - - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","vetNewCaseDocuments","followUpNoncomplianceOfDirections","registerNewCase","stitchCollateHearingBundle","processPostponementDirections","processFurtherEvidence","createDueDate","issueDueDate","processListingDirectionsListed","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed","reviewOrder" - - - - - - - - - "hearing-centre-admin" - - - "Read,Own,Claim,Unclaim,Manage,Complete" - - - "ADMIN" - - - - - - 1 - - - false - - - - - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","vetNewCaseDocuments","followUpNoncomplianceOfDirections","registerNewCase","stitchCollateHearingBundle","processPostponementDirections","processFurtherEvidence","createDueDate","issueDueDate","processListingDirectionsListed","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed","reviewOrder" - - - - - - - - - "hearing-centre-team-leader" - - - "Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete" - - - "ADMIN" - - - - - - 2 - - - false - - - - - "reviewNewCaseAndProvideDirectionsLO","reviewTimeExtensionRequestLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","reviewListCaseLO","reviewOtherRequestLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewReinstatementRequestLO","reviewSpecificAccessRequestLegalOps","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO" - - - - - - - - - "senior-tribunal-caseworker" - - - "Read,Own,Claim,Manage,Assign,Unassign,Complete,Cancel" - - - "LEGAL_OPERATIONS" - - - - - - 1 - - - false - - - - - "reviewNewCaseAndProvideDirectionsLO","reviewTimeExtensionRequestLO","reviewStrikeOutRequestLO","reviewStayRequestLO","reviewStayRequestCaseListedLO","reviewListingDirectionsLO","reviewListingDirectionsCaseListedLO","reviewWithdrawalRequestLO","reviewRule27RequestLO","reviewListCaseLO","reviewOtherRequestLO","reviewListCaseWithin5DaysLO","reviewPostponementRequestLO","reviewReinstatementRequestLO","reviewRule27RequestCaseListedLO","reviewWithdrawalRequestCaseListedLO" - - - - - - - - - "tribunal-caseworker" - - - "Read,Own,Claim,Assign,Unassign,Complete,Cancel" - - - "LEGAL_OPERATIONS" - - - - - - 2 - - - false - - - - - "reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewCorrectionsRequest","reviewWrittenReasonsRequest","reviewReinstatementRequestJudge","reviewSetAsideRequest","reviewStayRequestJudge","reviewNewCaseAndProvideDirectionsJudge","reviewOtherRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewListingDirectionsJudge","reviewListCaseJudge","reviewStrikeOutRequestJudge","reviewTimeExtensionRequestJudge","reviewListingDirectionsCaseListedJudge","reviewWithdrawalRequestCaseListedJudge","reviewStayRequestCaseListedJudge","reviewRule27RequestCaseListedJudge" - - - - - - - - - "senior-judge" - - - "Read,Execute,Claim,Manage,Assign,Unassign,Complete,Cancel" - - - "JUDICIAL" - - - 328 - - - 1 - - - false - - - - - "reviewListCaseWithin5DaysJudge","reviewPostponementRequestJudge","reviewCorrectionsRequest","reviewWrittenReasonsRequest","reviewReinstatementRequestJudge","reviewSetAsideRequest","reviewStayRequestJudge","reviewNewCaseAndProvideDirectionsJudge","reviewOtherRequestJudge","reviewWithdrawalRequestJudge","reviewRule27RequestJudge","reviewListingDirectionsJudge","reviewListCaseJudge","reviewStrikeOutRequestJudge","reviewTimeExtensionRequestJudge","reviewListingDirectionsCaseListedJudge","reviewWithdrawalRequestCaseListedJudge","reviewStayRequestCaseListedJudge","reviewRule27RequestCaseListedJudge" - - - - - - - - - "judge" - - - "Read,Own,Claim,Assign,Unassign,Complete,Cancel" - - - "JUDICIAL" - - - 328 - - - 2 - - - false - - "Judge Access Request Permissions" @@ -405,61 +173,33 @@ false - - - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","vetNewCaseDocuments","followUpNoncomplianceOfDirections","registerNewCase","stitchCollateHearingBundle","processPostponementDirections","processFurtherEvidence","createDueDate","issueDueDate","processListingDirectionsListed","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed","reviewOrder" + + "Access Request for Legal Ops" + + "reviewSpecificAccessRequestLegalOps" - + - + - - "ctsc" + + "senior-tribunal-caseworker" - - "Read,Own,Claim,Unclaim,Manage,Complete" + + "Read,Own,Claim,Manage,Assign,Unassign,Complete,Cancel" - - "CTSC" + + "LEGAL_OPERATIONS" - + - + 1 - - false - - - - - "processCaseWithdrawalDirections","processRule27Decision","processListingDirections","processDirectionsReListedCase","processDirectionsReListedCaseWithin5Days","processSetAsideDirections","processCorrections","processDirectionsReturned","processTimeExtensionDirectionsReturned","processReinstatementDecisionNotice","processOtherDirectionsReturned","processWrittenReasons","processStrikeOutDirectionsReturned","processStayDirections","issueDecisionNotice","completeHearingOutcome","issueCaseToRespondent","vetNewCaseDocuments","followUpNoncomplianceOfDirections","registerNewCase","stitchCollateHearingBundle","processPostponementDirections","processFurtherEvidence","createDueDate","issueDueDate","processListingDirectionsListed","processCaseWithdrawalDirectionsListed","processStayDirectionsListed","processRule27DecisionListed","reviewOrder" - - - - - - - - - "ctsc-team-leader" - - - "Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete" - - - "CTSC" - - - - - - 2 - - + false diff --git a/src/main/resources/dmn/wa-task-types-st_cic-criminalinjuriescompensation.dmn b/src/main/resources/dmn/wa-task-types-st_cic-criminalinjuriescompensation.dmn index b0f5f7175b..fa60181dd1 100644 --- a/src/main/resources/dmn/wa-task-types-st_cic-criminalinjuriescompensation.dmn +++ b/src/main/resources/dmn/wa-task-types-st_cic-criminalinjuriescompensation.dmn @@ -1,5 +1,5 @@ - + @@ -9,688 +9,6 @@ - - - - - - "processCaseWithdrawalDirections" - - - "Process case withdrawal directions" - - - - - - - - "processCaseWithdrawalDirectionsListed" - - - "Process case withdrawal directions listed" - - - - - - - - "processRule27Decision" - - - "Process Rule 27 decision" - - - - - - - - "processRule27DecisionListed" - - - "Process Rule 27 decision listed" - - - - - - - - "processListingDirections" - - - "Process listing directions" - - - - - - - - "processListingDirectionsListed" - - - "Process listing directions listed" - - - - - - - - "processDirectionsReListedCase" - - - "Process directions re. listed case" - - - - - - - - "processDirectionsReListedCaseWithin5Days" - - - "Process directions re. listed case (within 5 days)" - - - - - - - - "processSetAsideDirections" - - - "Process set aside directions" - - - - - - - - "processCorrections" - - - "Process corrections" - - - - - - - - "processDirectionsReturned" - - - "Process directions returned" - - - - - - - - "processPostponementDirections" - - - "Process postponement directions" - - - - - - - - "processTimeExtensionDirectionsReturned" - - - "Process time extension directions returned" - - - - - - - - "processReinstatementDecisionNotice" - - - "Process reinstatement decision notice" - - - - - - - - "processOtherDirectionsReturned" - - - "Process other directions returned" - - - - - - - - "processWrittenReasons" - - - "Process written reasons" - - - - - - - - "processStrikeOutDirectionsReturned" - - - "Process strike out directions returned" - - - - - - - - "processStayDirections" - - - "Process stay directions" - - - - - - - - "processStayDirectionsListed" - - - "Process stay directions listed" - - - - - - - - "issueDecisionNotice" - - - "Issue decision notice" - - - - - - - - "completeHearingOutcome" - - - "Complete hearing outcome" - - - - - - - - "issueCaseToRespondent" - - - "Issue case to respondent" - - - - - - - - "vetNewCaseDocuments" - - - "Vet new case documents" - - - - - - - - "reviewNewCaseAndProvideDirectionsLO" - - - "Review new case and provide directions - Legal Officer" - - - - - - - - "reviewTimeExtensionRequestLO" - - - "Review time extension request - Legal Officer" - - - - - - - - "reviewStrikeOutRequestLO" - - - "Review strike out request - Legal Officer" - - - - - - - - "reviewStayRequestLO" - - - "Review stay request - Legal Officer" - - - - - - - - "reviewStayRequestCaseListedLO" - - - "Review stay request case listed - Legal Officer" - - - - - - - - "reviewListingDirectionsLO" - - - "Review listing directions - Legal Officer" - - - - - - - - "reviewListingDirectionsCaseListedLO" - - - "Review listing directions case listed - Legal Officer" - - - - - - - - "reviewWithdrawalRequestLO" - - - "Review withdrawal request - Legal Officer" - - - - - - - - "reviewWithdrawalRequestCaseListedLO" - - - "Review withdrawal request case listed - Legal Officer" - - - - - - - - "reviewRule27RequestLO" - - - "Review Rule 27 request - Legal Officer" - - - - - - - - "reviewRule27RequestCaseListedLO" - - - "Review Rule 27 request case listed - Legal Officer" - - - - - - - - "reviewListCaseLO" - - - "Review list case - Legal Officer" - - - - - - - - "reviewOtherRequestLO" - - - "Review reinstatement request - Legal Officer" - - - - - - - - "reviewListCaseWithin5DaysLO" - - - "Review list case (within 5 days) - Legal Officer" - - - - - - - - "reviewPostponementRequestLO" - - - "Review postponement request - Legal Officer" - - - - - - - - "reviewReinstatementRequestLO" - - - "Review reinstatement request - Legal Officer" - - - - - - - - "reviewListCaseWithin5DaysJudge" - - - "Review list case (within 5 days) - Judge" - - - - - - - - "reviewPostponementRequestJudge" - - - "Review postponement request - Judge" - - - - - - - - "reviewCorrectionsRequest" - - - "Review corrections request" - - - - - - - - "reviewWrittenReasonsRequest" - - - "Review written reasons request" - - - - - - - - "reviewReinstatementRequestJudge" - - - "Review reinstatement request - Judge" - - - - - - - - "reviewSetAsideRequest" - - - "Review set aside request" - - - - - - - - "reviewStayRequestJudge" - - - "Review stay request - Judge" - - - - - - - - "reviewStayRequestCaseListedJudge" - - - "Review stay request case listed - Judge" - - - - - - - - "reviewNewCaseAndProvideDirectionsJudge" - - - "Review new case and provide directions - Judge" - - - - - - - - "reviewOtherRequestJudge" - - - "Review other request - Judge" - - - - - - - - "reviewWithdrawalRequestJudge" - - - "Review withdrawal request - Judge" - - - - - - - - "reviewWithdrawalRequestCaseListedJudge" - - - "Review withdrawal request case listed - Judge" - - - - - - - - "reviewRule27RequestJudge" - - - "Review Rule 27 request - Judge" - - - - - - - - "reviewRule27RequestCaseListedJudge" - - - "Review Rule 27 request case listed - Judge" - - - - - - - - "reviewListingDirectionsJudge" - - - "Review listing directions - Judge" - - - - - - - - "reviewListingDirectionsCaseListedJudge" - - - "Review listing directions case listed - Judge" - - - - - - - - "reviewListCaseJudge" - - - "Review list case - Judge" - - - - - - - - "reviewStrikeOutRequestJudge" - - - "Review strike out request - Judge" - - - - - - - - "reviewTimeExtensionRequestJudge" - - - "Review time extension request - Judge" - - - - - - - - "followUpNoncomplianceOfDirections" - - - "Follow up noncompliance of directions" - - - - - - - - "registerNewCase" - - - "Register new case" - - - - - - - - "processFurtherEvidence" - - - "Process further evidence" - - - - - - - - "stitchCollateHearingBundle" - - - "Stitch/collate hearing bundle" - - @@ -735,39 +53,6 @@ "Review Specific Access Request CTSC" - - - - - - "createDueDate" - - - "Create due date" - - - - - - - - "issueDueDate" - - - "Issue due date" - - - - - - - - "reviewOrder" - - - "Review Order" - - diff --git a/src/test/java/uk/gov/hmcts/sptribs/DmnDecisionTable.java b/src/test/java/uk/gov/hmcts/sptribs/DmnDecisionTable.java index 8c19c0fb52..f3ee5e4240 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/DmnDecisionTable.java +++ b/src/test/java/uk/gov/hmcts/sptribs/DmnDecisionTable.java @@ -6,20 +6,11 @@ public enum DmnDecisionTable { WA_TASK_ALLOWED_DAYS_WA_WACASETYPE("wa-task-allowed-days-wa-wacasetype", "wa-task-allowed-days-wa-wacasetype.dmn"), - WA_TASK_COMPLETION_ST_CIC_CRIMINALINJURIESCOMPENSATION( - "wa-task-completion-st_cic-criminalinjuriescompensation", - "dmn/wa-task-completion-st_cic-criminalinjuriescompensation.dmn"), WA_TASK_TYPES_ST_CIC_CRIMINALINJURIESCOMPENSATION("wa-task-types-st_cic-criminalinjuriescompensation", "dmn/wa-task-types-st_cic-criminalinjuriescompensation.dmn"), - WA_TASK_CANCELLATION_ST_CIC_CRIMINALINJURIESCOMPENSATION( - "wa-task-cancellation-st_cic-criminalinjuriescompensation", - "dmn/wa-task-cancellation-st_cic-criminalinjuriescompensation.dmn"), WA_TASK_CONFIGURATION_ST_CIC_CRIMINALINJURIESCOMPENSATION( "wa-task-configuration-st_cic-criminalinjuriescompensation", "dmn/wa-task-configuration-st_cic-criminalinjuriescompensation.dmn"), - WA_TASK_INITIATION_ST_CIC_CRIMINALINJURIESCOMPENSATION( - "wa-task-initiation-st_cic-criminalinjuriescompensation", - "dmn/wa-task-initiation-st_cic-criminalinjuriescompensation.dmn"), WA_TASK_PERMISSIONS_ST_CIC_CRIMINALINJURIESCOMPENSATION( "wa-task-permissions-st_cic-criminalinjuriescompensation", "dmn/wa-task-permissions-st_cic-criminalinjuriescompensation.dmn"); diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCaseBuiltTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCaseBuiltTest.java index 889c8a5fce..980b37a876 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCaseBuiltTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCaseBuiltTest.java @@ -3,20 +3,30 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.ccd.sdk.ConfigBuilderImpl; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; import uk.gov.hmcts.ccd.sdk.api.Event; +import uk.gov.hmcts.ccd.sdk.api.callback.AboutToStartOrSubmitResponse; import uk.gov.hmcts.reform.ccd.client.model.SubmittedCallbackResponse; import uk.gov.hmcts.sptribs.ciccase.model.CaseData; import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; +import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseManagement; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueCaseToRespondent; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.vetNewCaseDocuments; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; +import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_CASE_BUILT; @ExtendWith(MockitoExtension.class) @@ -25,6 +35,9 @@ class CaseWorkerCaseBuiltTest { @InjectMocks private CaseworkerCaseBuilt caseworkerCaseBuilt; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -36,10 +49,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_CASE_BUILT); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -59,4 +68,17 @@ void shouldSuccessfullyBuiltCase() { assertThat(stayedResponse.getConfirmationHeader()).contains("# Case built successful"); } + + @Test + void shouldEnqueueTasksInAboutToSubmit() { + final CaseDetails details = new CaseDetails<>(); + details.setData(CaseData.builder().build()); + details.setId(TEST_CASE_ID); + + final AboutToStartOrSubmitResponse response = caseworkerCaseBuilt.aboutToSubmit(details, details); + + assertThat(response.getState()).isEqualTo(CaseManagement); + verify(taskManagementService).enqueueCompletionTasks(List.of(vetNewCaseDocuments), TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks(List.of(issueCaseToRespondent), details.getData(), TEST_CASE_ID); + } } diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCloseTheCaseTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCloseTheCaseTest.java index 65297c3e47..dae13910ec 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCloseTheCaseTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerCloseTheCaseTest.java @@ -30,8 +30,11 @@ import uk.gov.hmcts.sptribs.document.model.DocumentType; import uk.gov.hmcts.sptribs.judicialrefdata.JudicialService; import uk.gov.hmcts.sptribs.notification.dispatcher.CaseWithdrawnNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; import java.util.ArrayList; +import java.util.Arrays; import java.util.Collections; import java.util.List; import java.util.Set; @@ -39,6 +42,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.anyList; import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.document.DocumentConstants.DOCUMENT_VALIDATION_MESSAGE; @@ -69,6 +73,9 @@ class CaseWorkerCloseTheCaseTest { @Mock private CaseWithdrawnNotification caseWithdrawnNotification; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -80,10 +87,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_CLOSE_THE_CASE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -161,6 +164,7 @@ void shouldSuccessfullyChangeCaseManagementStateToClosedState() { assertThat(closedCase).isNotNull(); assertThat(closedCase.getConfirmationHeader()).contains("Case closed"); assertThat(response.getState()).isEqualTo(State.CaseClosed); + verify(taskManagementService).enqueueCancellationTasks(Arrays.stream(TaskType.values()).toList(), TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDatesTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDatesTest.java index b37259230f..a61708b891 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDatesTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerManageOrderDueDatesTest.java @@ -22,6 +22,7 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.Clock; import java.time.LocalDate; @@ -33,7 +34,9 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -48,6 +51,9 @@ class CaseWorkerManageOrderDueDatesTest { @Mock private OrderService orderService; + @Mock + private TaskManagementService taskManagementService; + private final Clock fixedClock = Clock.fixed( LocalDate.of(2026, 7, 15) .atStartOfDay(ZoneId.systemDefault()) @@ -60,7 +66,7 @@ class CaseWorkerManageOrderDueDatesTest { @BeforeEach void setUp() { caseWorkerManageOrderDueDate = - new CaseWorkerManageOrderDueDate(orderService, fixedClock); + new CaseWorkerManageOrderDueDate(orderService, fixedClock, taskManagementService); } @@ -74,10 +80,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_AMEND_DUE_DATE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -117,6 +119,7 @@ void shouldSuccessfullySaveDraftOrder() { //Then assertThat(draftCreatedResponse).isNotNull(); assertThat(response).isNotNull(); + verify(taskManagementService).enqueueCompletionTasks(List.of(followUpNoncomplianceOfDirections), TEST_CASE_ID); } @@ -224,4 +227,3 @@ private ListValue listValue(String id, DateModel model) { } - diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudgeTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudgeTest.java index 2cd66c645a..eb2dec31bd 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudgeTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToJudgeTest.java @@ -5,6 +5,7 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.ccd.sdk.ConfigBuilderImpl; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -17,9 +18,17 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.ISSUE_CASE_CANCELLABLE_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.REFERRAL_COMPLETABLE_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedJudge; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -33,6 +42,9 @@ public class CaseWorkerReferToJudgeTest { @InjectMocks private CaseWorkerReferToJudge caseWorkerReferToJudge; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -44,10 +56,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_REFER_TO_JUDGE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -111,6 +119,26 @@ void shouldSetReferralTypeForWA(ReferralReason referralReason) { assertThat(response1.getData().getCicCase().getReferralTypeForWA()).isEqualTo(referralReason.getLabel()); } + @Test + void shouldEnqueueTaskManagementActionsForAwaitingHearingStayRequest() { + final CaseDetails updatedCaseDetails = getCaseDetails(); + final CaseDetails beforeDetails = new CaseDetails<>(); + updatedCaseDetails.setState(State.AwaitingHearing); + updatedCaseDetails.getData().setReferToJudge(ReferToJudge.builder() + .referralReason(ReferralReason.STAY_REQUEST) + .build()); + + caseWorkerReferToJudge.aboutToSubmit(updatedCaseDetails, beforeDetails); + + verify(taskManagementService).enqueueCancellationTasks(ISSUE_CASE_CANCELLABLE_TASKS, TEST_CASE_ID); + verify(taskManagementService).enqueueCompletionTasks(REFERRAL_COMPLETABLE_TASKS, TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks( + eq(List.of(reviewStayRequestCaseListedJudge)), + eq(updatedCaseDetails.getData()), + eq(TEST_CASE_ID) + ); + } + private CaseDetails getCaseDetails() { CaseData caseData = caseData(); final CaseDetails caseDetails = new CaseDetails<>(); diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficerTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficerTest.java index 92fa9141f6..ed214da75f 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficerTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseWorkerReferToLegalOfficerTest.java @@ -5,6 +5,7 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.ccd.sdk.ConfigBuilderImpl; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -18,11 +19,18 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDate; +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.ISSUE_CASE_CANCELLABLE_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.TaskTypeCollections.REFERRAL_COMPLETABLE_TASKS; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedLO; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -36,6 +44,9 @@ class CaseWorkerReferToLegalOfficerTest { @InjectMocks private CaseWorkerReferToLegalOfficer caseWorkerReferToLegalOfficer; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -47,10 +58,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_REFER_TO_LEGAL_OFFICER); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -130,6 +137,26 @@ void shouldNotSetReferralTypeForWAWhenWAIsNotEnabled(ReferralReason referralReas assertThat(response1.getData().getCicCase().getReferralTypeForWA()).isNull(); } + @Test + void shouldEnqueueTaskManagementActionsForAwaitingHearingStayRequest() { + final CaseDetails updatedCaseDetails = getCaseDetails(); + final CaseDetails beforeDetails = new CaseDetails<>(); + updatedCaseDetails.setState(State.AwaitingHearing); + updatedCaseDetails.getData().setReferToLegalOfficer(ReferToLegalOfficer.builder() + .referralReason(ReferralReason.STAY_REQUEST) + .build()); + + caseWorkerReferToLegalOfficer.aboutToSubmit(updatedCaseDetails, beforeDetails); + + verify(taskManagementService).enqueueCancellationTasks(ISSUE_CASE_CANCELLABLE_TASKS, TEST_CASE_ID); + verify(taskManagementService).enqueueCompletionTasks(REFERRAL_COMPLETABLE_TASKS, TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks( + eq(List.of(reviewStayRequestCaseListedLO)), + eq(updatedCaseDetails.getData()), + eq(TEST_CASE_ID) + ); + } + private CaseDetails getCaseDetails() { CaseData caseData = caseData(); final CaseDetails caseDetails = new CaseDetails<>(); diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNoteTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNoteTest.java index 346b5abb36..944110bd1e 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNoteTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerAddNoteTest.java @@ -67,10 +67,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_ADD_NOTE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearingTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearingTest.java index 20806f1517..84adfa7011 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearingTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCancelHearingTest.java @@ -26,6 +26,7 @@ import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; import uk.gov.hmcts.sptribs.notification.dispatcher.CancelHearingNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import uk.gov.hmcts.sptribs.testutil.TestEventConstants; import java.time.LocalDate; @@ -36,14 +37,18 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.completeHearingOutcome; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.stitchCollateHearingBundle; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.HEARING_DATE_1; import static uk.gov.hmcts.sptribs.testutil.TestConstants.HEARING_TIME; import static uk.gov.hmcts.sptribs.testutil.TestConstants.SOLICITOR_ADDRESS; import static uk.gov.hmcts.sptribs.testutil.TestConstants.SUBJECT_ADDRESS; +import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_SOLICITOR_EMAIL; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_SUBJECT_EMAIL; import static uk.gov.hmcts.sptribs.testutil.TestDataHelper.getAdditionalHearingDates; @@ -62,6 +67,9 @@ class CaseworkerCancelHearingTest { @Mock private CancelHearingNotification cancelHearingNotification; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -73,10 +81,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_CANCEL_HEARING); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -132,6 +136,7 @@ void shouldReturnCancelHearingWhenThereAreTwoHearingDates() { final CaseDetails beforeDetails = new CaseDetails<>(); updatedCaseDetails.setData(caseData); updatedCaseDetails.setState(State.AwaitingOutcome); + updatedCaseDetails.setId(TEST_CASE_ID); //When AboutToStartOrSubmitResponse response = @@ -141,6 +146,10 @@ void shouldReturnCancelHearingWhenThereAreTwoHearingDates() { //Then assertThat(cancelled).isNotNull(); assertThat(response).isNotNull(); + verify(taskManagementService).enqueueCancellationTasks( + List.of(completeHearingOutcome, stitchCollateHearingBundle), + TEST_CASE_ID + ); } @Test @@ -170,6 +179,7 @@ void shouldReturnCancelHearingWhenThereAreTwoHearingDatesWithPost() { final CaseDetails beforeDetails = new CaseDetails<>(); updatedCaseDetails.setData(caseData); updatedCaseDetails.setState(State.AwaitingOutcome); + updatedCaseDetails.setId(TEST_CASE_ID); //When AboutToStartOrSubmitResponse response = @@ -209,6 +219,7 @@ void shouldReturnCancelHearingWhenThereIsOneHearingDate() { final CaseDetails beforeDetails = new CaseDetails<>(); updatedCaseDetails.setData(caseData); updatedCaseDetails.setState(State.AwaitingOutcome); + updatedCaseDetails.setId(TEST_CASE_ID); //When AboutToStartOrSubmitResponse response = diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactPartiesTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactPartiesTest.java index ed4f6b9d46..309f2d7d72 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactPartiesTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerContactPartiesTest.java @@ -28,6 +28,7 @@ import uk.gov.hmcts.sptribs.document.model.DocumentType; import uk.gov.hmcts.sptribs.notification.dispatcher.ContactPartiesNotification; import uk.gov.hmcts.sptribs.notification.exception.NotificationException; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; import java.util.List; @@ -35,8 +36,11 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.caseworker.util.ErrorConstants.SELECT_AT_LEAST_ONE_CONTACT_PARTY; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.SOLICITOR_ADDRESS; @@ -63,6 +67,9 @@ class CaseworkerContactPartiesTest { @Mock private ContactPartiesSelectDocument contactPartiesSelectDocument; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -74,10 +81,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_CONTACT_PARTIES); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -135,6 +138,23 @@ void shouldSuccessfullyMoveToNextPage() { assertThat(response.getErrors()).isEmpty(); } + @Test + void shouldEnqueueCompletionTasksInAboutToSubmit() { + final CaseDetails updatedCaseDetails = new CaseDetails<>(); + updatedCaseDetails.setData(caseData()); + updatedCaseDetails.setState(State.CaseManagement); + updatedCaseDetails.setId(TEST_CASE_ID); + + final AboutToStartOrSubmitResponse response = + caseWorkerContactParties.aboutToSubmit(updatedCaseDetails, updatedCaseDetails); + + assertThat(response.getState()).isEqualTo(State.CaseManagement); + verify(taskManagementService).enqueueCompletionTasks( + List.of(followUpNoncomplianceOfDirections, processFurtherEvidence), + TEST_CASE_ID + ); + } + @Test void shouldNotSuccessfullyMoveToNextPageWithError() { @@ -325,4 +345,3 @@ void shouldRunAboutToStart() { assertThat(response.getData().getCicCase().getNotifyPartyMessage()).isEqualTo(""); } } - diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrderTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrderTest.java index ad2478667b..ddf02a7366 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrderTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateAndSendOrderTest.java @@ -23,6 +23,7 @@ import uk.gov.hmcts.sptribs.caseworker.model.Order; import uk.gov.hmcts.sptribs.caseworker.model.OrderIssuingType; import uk.gov.hmcts.sptribs.caseworker.util.CaseFlagsUtil; +import uk.gov.hmcts.sptribs.ciccase.model.AdminAction; import uk.gov.hmcts.sptribs.ciccase.model.CaseData; import uk.gov.hmcts.sptribs.ciccase.model.CicCase; import uk.gov.hmcts.sptribs.ciccase.model.OrderTemplate; @@ -32,6 +33,7 @@ import uk.gov.hmcts.sptribs.document.model.CICDocument; import uk.gov.hmcts.sptribs.notification.dispatcher.NewOrderIssuedNotification; import uk.gov.hmcts.sptribs.notification.exception.NotificationException; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDate; import java.time.LocalDateTime; @@ -44,6 +46,8 @@ import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; @@ -56,6 +60,8 @@ import static uk.gov.hmcts.sptribs.ciccase.model.RespondentCIC.RESPONDENT; import static uk.gov.hmcts.sptribs.ciccase.model.SchemeCic.Year2012; import static uk.gov.hmcts.sptribs.ciccase.model.SubjectCIC.SUBJECT; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOrder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -79,6 +85,9 @@ class CaseworkerCreateAndSendOrderTest { @Mock private NewOrderIssuedNotification newOrderIssuedNotification; + @Mock + private TaskManagementService taskManagementService; + private DateModel dateModel = DateModel.builder() .dueDate(LocalDate.of(2026, 1, 2)) .build(); @@ -190,6 +199,7 @@ void shouldSuccessfullyCreateAndSendNewAnonymisedOrder() { final CaseDetails details = new CaseDetails<>(); details.setData(caseData); + details.setId(TEST_CASE_ID); final var response = caseworkerCreateAndSendOrder.aboutToSubmit(details, caseDetailsBefore()); assertThat(response).isNotNull(); @@ -237,6 +247,7 @@ void shouldSuccessfullyCreateAndSendNewNonAnonymisedOrder() { caseData.setDraftOrderContentCIC(draftOrderContentCIC); details.setData(caseData); + details.setId(TEST_CASE_ID); final var response = caseworkerCreateAndSendOrder.aboutToSubmit(details, caseDetailsBefore()); @@ -286,6 +297,7 @@ void shouldApplyAnonymisationCaseFlagWhenAnonymityIsApplied() { final CaseDetails details = new CaseDetails<>(); details.setData(caseData); + details.setId(TEST_CASE_ID); final var response = caseworkerCreateAndSendOrder.aboutToSubmit(details, caseDetailsBefore()); assertThat(response).isNotNull(); @@ -350,6 +362,7 @@ void shouldNotApplyAnonymisationCaseFlagWhenAnonymityFlagExists() { final CaseDetails details = new CaseDetails<>(); details.setData(caseData); + details.setId(TEST_CASE_ID); final var response = caseworkerCreateAndSendOrder.aboutToSubmit(details, caseDetailsBefore()); assertThat(response).isNotNull(); @@ -401,6 +414,7 @@ void shouldSuccessfullySendUploadedOrder() { caseData.setOrderDueDates(List.of(ListValue.builder().value(dateModel).build())); details.setData(caseData); + details.setId(TEST_CASE_ID); final var response = caseworkerCreateAndSendOrder.aboutToSubmit(details, caseDetailsBefore()); @@ -543,6 +557,34 @@ void shouldShowErrorMessageWhenNotificationFailsForApplicant() { verify(newOrderIssuedNotification, times(1)).sendToApplicant(any(CaseData.class), anyString()); } + @Test + void shouldEnqueueInitiationTasksForCaseManagementWhenDueDateAndAdminActionPresent() { + final CaseDetails details = new CaseDetails<>(); + final CaseData caseData = CaseData.builder().build(); + CicCase cicCase = getCicCase(CREATE_AND_SEND_NEW_ORDER, YesOrNo.NO, null, + Document.builder().filename("order.pdf").build()); + cicCase.setAdminActionRequired(Set.of(AdminAction.ADMIN_ACTION_REQUIRED)); + caseData.setCicCase(cicCase); + caseData.setOrderDueDates(List.of(ListValue.builder().value(dateModel).build())); + caseData.setDraftOrderContentCIC(DraftOrderContentCIC.builder().orderTemplate(OrderTemplate.CIC3_RULE_27).build()); + + details.setData(caseData); + details.setId(TEST_CASE_ID); + details.setState(State.CaseManagement); + + caseworkerCreateAndSendOrder.aboutToSubmit(details, caseDetailsBefore()); + + verify(taskManagementService).enqueueCompletionTasks( + argThat(taskTypes -> !taskTypes.isEmpty()), + eq(TEST_CASE_ID) + ); + verify(taskManagementService).enqueueInitiationTasks( + eq(List.of(followUpNoncomplianceOfDirections, reviewOrder)), + eq(caseData), + eq(TEST_CASE_ID) + ); + } + private CaseDetails caseDetailsBefore() { final CaseDetails caseDetails = new CaseDetails<>(); final CaseData caseData = CaseData.builder().build(); diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundleTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundleTest.java index 5c2000e7d9..278fef696c 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundleTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateBundleTest.java @@ -22,6 +22,7 @@ import uk.gov.hmcts.sptribs.document.bundling.model.BundleIdAndTimestamp; import uk.gov.hmcts.sptribs.document.bundling.model.MultiBundleConfig; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocument; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.Clock; import java.time.Instant; @@ -38,6 +39,7 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.stitchCollateHearingBundle; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -64,6 +66,9 @@ class CaseworkerCreateBundleTest { @Mock private Clock clock; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -75,10 +80,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CREATE_BUNDLE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -125,6 +126,7 @@ void shouldSuccessfullyCreateBundle() { verify(bundlingService).getMultiBundleConfig(); verify(bundlingService).getMultiBundleConfigs(); verify(bundlingService).buildBundleListValues(anyList()); + verify(taskManagementService).enqueueCompletionTasks(List.of(stitchCollateHearingBundle), TEST_CASE_ID); final CaseData responseData = response.getData(); assertThat(responseData) diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrderTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrderTest.java index 8a39d2b727..7ba381838e 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrderTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateDraftOrderTest.java @@ -23,14 +23,20 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; import java.util.List; import java.util.UUID; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.DOUBLE_HYPHEN; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.createDueDate; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDueDate; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -47,6 +53,9 @@ class CaseworkerCreateDraftOrderTest { @Mock private OrderService orderService; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -58,10 +67,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_CREATE_DRAFT_ORDER); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -220,5 +225,28 @@ void shouldHandlePreExistingDraftOrderList() { assertThat(response.getData().getCicCase().getDraftOrderCICList().get(1).getValue().getDraftOrderContentCIC()) .isEqualTo(existingDraftOrderCIC.getDraftOrderContentCIC()); } -} + @Test + void shouldEnqueueIssueDueDateWhenDraftOrderCreatedInCaseManagementWithBlankReferral() { + final CaseDetails details = new CaseDetails<>(); + final CaseDetails beforeDetails = new CaseDetails<>(); + final CaseData caseData = caseData(); + + caseData.getCicCase().setOrderTemplateIssued(Document.builder().filename("a--b--02-02-2002 11:11:11.pdf").build()); + caseData.setDraftOrderContentCIC(DraftOrderContentCIC.builder() + .orderTemplate(OrderTemplate.CIC6_GENERAL_DIRECTIONS) + .build()); + + details.setData(caseData); + details.setId(TEST_CASE_ID); + details.setState(State.CaseManagement); + + caseworkerCreateDraftOrder.aboutToSubmit(details, beforeDetails); + + verify(taskManagementService).enqueueInitiationTasks(List.of(issueDueDate), caseData, TEST_CASE_ID); + verify(taskManagementService).enqueueCompletionTasks( + argThat(taskTypes -> taskTypes.contains(createDueDate)), + eq(TEST_CASE_ID) + ); + } +} diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateHearingSummaryTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateHearingSummaryTest.java index 812146a8da..2a5d7f9581 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateHearingSummaryTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerCreateHearingSummaryTest.java @@ -28,16 +28,21 @@ import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocumentUpload; import uk.gov.hmcts.sptribs.judicialrefdata.JudicialService; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.List; import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.completeHearingOutcome; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDecisionNotice; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; +import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; import static uk.gov.hmcts.sptribs.testutil.TestDataHelper.getCaseworkerCICDocumentUploadList; import static uk.gov.hmcts.sptribs.testutil.TestDataHelper.getDynamicList; import static uk.gov.hmcts.sptribs.testutil.TestDataHelper.getRecordListing; @@ -58,6 +63,9 @@ class CaseworkerCreateHearingSummaryTest { @Mock private JudicialService judicialService; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -69,10 +77,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_CREATE_HEARING_SUMMARY); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -129,6 +133,7 @@ void shouldRunAboutToSubmit() { recordListing.setSummary(hearingSummary); updatedCaseDetails.setData(caseData); + updatedCaseDetails.setId(TEST_CASE_ID); final CaseDetails beforeDetails = new CaseDetails<>(); when(recordListHelper.saveSummary(any())).thenReturn(recordListing); when(judicialService.populateJudicialId(any())).thenReturn("personal_code"); @@ -147,6 +152,8 @@ void shouldRunAboutToSubmit() { .isNull(); assertThat(response.getData().getListing().getSummary().getRecFileUpload()).hasSize(0); assertThat(response.getData().getListing().getSummary().getRecFile()).hasSize(0); + verify(taskManagementService).enqueueCompletionTasks(List.of(completeHearingOutcome), TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks(List.of(issueDecisionNotice), caseData, TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmendTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmendTest.java index ef81a5fdd2..643b170716 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmendTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementAmendTest.java @@ -3,6 +3,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.ccd.sdk.ConfigBuilderImpl; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -26,15 +27,18 @@ import uk.gov.hmcts.sptribs.document.model.CICDocument; import uk.gov.hmcts.sptribs.document.model.CaseworkerCICDocument; import uk.gov.hmcts.sptribs.document.model.DocumentType; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; import java.util.List; import java.util.UUID; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CASEWORKER_DOCUMENT_MANAGEMENT_AMEND; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.document.model.DocumentType.APPLICATION_FORM; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -55,6 +59,9 @@ class CaseworkerDocumentManagementAmendTest { @InjectMocks private DocumentManagementAmendDocuments amendCaseDocuments; + @Mock + private TaskManagementService taskManagementService; + private static final String UPDATED_EMAIL_CONTENT = "updated email content"; @Test @@ -67,10 +74,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_DOCUMENT_MANAGEMENT_AMEND); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -125,6 +128,7 @@ void shouldSuccessfullyAmendCaseDocument() { .getApplicantDocumentsUploaded().getFirst() .getValue().getDocumentCategory()).isEqualTo(APPLICATION_FORM); assertThat(documentMgmtResponse).isNotNull(); + verify(taskManagementService).enqueueCompletionTasks(List.of(processFurtherEvidence), TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementTest.java index 526e01f307..a5cdadedf7 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerDocumentManagementTest.java @@ -3,6 +3,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.ccd.sdk.ConfigBuilderImpl; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -17,9 +18,15 @@ import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; import uk.gov.hmcts.sptribs.document.model.DocumentType; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -38,6 +45,9 @@ public class CaseworkerDocumentManagementTest { @InjectMocks private UploadCaseDocuments uploadCaseDocuments; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -49,10 +59,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_DOCUMENT_MANAGEMENT); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -112,6 +118,8 @@ void shouldSuccessfullyAddDocumentInAboutToSubmit() { .getCaseworkerCICDocument().getFirst().getValue().getDocumentLink().getFilename()) .isEqualTo("file.pdf"); assertThat(response.getData().getAllDocManagement().getCaseworkerCICDocument().getFirst().getValue().getDate()).isNotNull(); + verify(taskManagementService).enqueueCompletionTasks(List.of(followUpNoncomplianceOfDirections), TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks(List.of(processFurtherEvidence), caseData, TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCaseTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCaseTest.java index 8d272394c3..63eabdb13b 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCaseTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditCaseTest.java @@ -23,14 +23,20 @@ import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; import uk.gov.hmcts.sptribs.common.service.SubmissionService; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.HashSet; +import java.util.List; import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.registerNewCase; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.vetNewCaseDocuments; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.APPLICANT_FIRST_NAME; @@ -49,9 +55,12 @@ class CaseworkerEditCaseTest { @Mock private SubmissionService submissionService; + @Mock + private TaskManagementService taskManagementService; + @BeforeEach public void setUp() { - caseworkerEditCase = new CaseworkerEditCase(submissionService); + caseworkerEditCase = new CaseworkerEditCase(submissionService, taskManagementService); } @Test @@ -65,10 +74,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_EDIT_CASE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -105,6 +110,8 @@ void shouldSuccessfullyEditDssCase() { //Then assertThat(response.getData()).isNotNull(); assertThat(response.getState()).isEqualTo(State.Submitted); + verify(taskManagementService).enqueueCompletionTasks(List.of(registerNewCase, processFurtherEvidence), TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks(List.of(vetNewCaseDocuments), response.getData(), TEST_CASE_ID); } @Test @@ -133,6 +140,8 @@ void shouldSuccessfullyEditCase() { //Then assertThat(response.getData()).isNotNull(); assertThat(stayedResponse).isNotNull(); + verify(taskManagementService).enqueueCompletionTasks(List.of(registerNewCase, processFurtherEvidence), TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks(List.of(), response.getData(), TEST_CASE_ID); } diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrderTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrderTest.java index 57b996df75..20b3416d5b 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrderTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditDraftOrderTest.java @@ -56,10 +56,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_EDIT_DRAFT_ORDER); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListingTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListingTest.java index ded2b04714..422661ec6b 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListingTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerEditRecordListingTest.java @@ -86,10 +86,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_EDIT_RECORD_LISTING); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCaseTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCaseTest.java index 87592a95cc..7ce3c8c7e6 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCaseTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueCaseTest.java @@ -25,6 +25,7 @@ import uk.gov.hmcts.sptribs.document.model.DocumentType; import uk.gov.hmcts.sptribs.notification.dispatcher.CaseIssuedNotification; import uk.gov.hmcts.sptribs.notification.exception.NotificationException; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.util.ArrayList; import java.util.List; @@ -32,11 +33,14 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.ciccase.model.ApplicantCIC.APPLICANT_CIC; import static uk.gov.hmcts.sptribs.ciccase.model.RepresentativeCIC.REPRESENTATIVE; import static uk.gov.hmcts.sptribs.ciccase.model.RespondentCIC.RESPONDENT; import static uk.gov.hmcts.sptribs.ciccase.model.SubjectCIC.SUBJECT; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.createDueDate; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueCaseToRespondent; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.SOLICITOR_ADDRESS; @@ -63,6 +67,9 @@ class CaseworkerIssueCaseTest { @Mock private CaseIssuedNotification caseIssuedNotification; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -74,10 +81,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_ISSUE_CASE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -128,6 +131,9 @@ void shouldSuccessfullyIssueTheCase() { assertThat(submittedResponse).isNotNull(); assertThat(submittedResponse.getConfirmationHeader()) .contains("# Case issued \n## This case has now been issued."); + + verify(taskManagementService).enqueueCompletionTasks(List.of(issueCaseToRespondent), TEST_CASE_ID); + verify(taskManagementService).enqueueInitiationTasks(List.of(createDueDate), caseData, TEST_CASE_ID); } diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueDecisionTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueDecisionTest.java index 6b2d4c44d1..66697b55ce 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueDecisionTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueDecisionTest.java @@ -30,18 +30,23 @@ import uk.gov.hmcts.sptribs.document.content.DocmosisTemplateConstants; import uk.gov.hmcts.sptribs.document.model.CICDocument; import uk.gov.hmcts.sptribs.notification.dispatcher.DecisionIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import java.util.List; import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyMap; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseManagement; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDecisionNotice; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; +import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; import static uk.gov.hmcts.sptribs.testutil.TestDataHelper.caseData; import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_ISSUE_DECISION; @@ -63,6 +68,9 @@ class CaseworkerIssueDecisionTest { @Mock private DecisionIssuedNotification decisionIssuedNotification; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -74,10 +82,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_ISSUE_DECISION); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -103,12 +107,14 @@ void shouldSetState() { decision.setDecisionDocument(document); caseData.setCaseIssueDecision(decision); details.setData(caseData); + details.setId(TEST_CASE_ID); //When AboutToStartOrSubmitResponse response = issueDecision.aboutToSubmit(details, beforeDetails); //Then assertThat(response.getState()).isEqualTo(CaseManagement); + verify(taskManagementService).enqueueCompletionTasks(List.of(issueDecisionNotice), TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecisionTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecisionTest.java index 9767164db3..6533a2c4c5 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecisionTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerIssueFinalDecisionTest.java @@ -31,14 +31,19 @@ import uk.gov.hmcts.sptribs.document.content.FinalDecisionTemplateContent; import uk.gov.hmcts.sptribs.document.model.CICDocument; import uk.gov.hmcts.sptribs.notification.dispatcher.CaseFinalDecisionIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import java.util.List; import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseClosed; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDecisionNotice; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; +import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; import static uk.gov.hmcts.sptribs.testutil.TestDataHelper.caseData; import static uk.gov.hmcts.sptribs.testutil.TestEventConstants.CASEWORKER_ISSUE_FINAL_DECISION; @@ -57,6 +62,9 @@ class CaseworkerIssueFinalDecisionTest { @Mock private CaseFinalDecisionIssuedNotification caseFinalDecisionIssuedNotification; + @Mock + private TaskManagementService taskManagementService; + @InjectMocks private IssueFinalDecisionSelectTemplate issueFinalDecisionSelectTemplate; @@ -71,10 +79,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_ISSUE_FINAL_DECISION); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -137,6 +141,7 @@ void shouldIssueCaseFinalDecision() { caseIssueFinalDecision.setDocument(document); caseData.setCaseIssueFinalDecision(caseIssueFinalDecision); details.setData(caseData); + details.setId(TEST_CASE_ID); //When AboutToStartOrSubmitResponse response = issueFinalDecision.aboutToSubmit(details, beforeDetails); @@ -144,6 +149,7 @@ void shouldIssueCaseFinalDecision() { //Then assertThat(response.getState()) .isEqualTo(CaseClosed); + verify(taskManagementService).enqueueCompletionTasks(List.of(issueDecisionNotice), TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearingTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearingTest.java index 994125ac29..0f6b1a17c1 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearingTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerPostponeHearingTest.java @@ -30,6 +30,8 @@ import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; import uk.gov.hmcts.sptribs.notification.dispatcher.HearingPostponedNotification; import uk.gov.hmcts.sptribs.notification.exception.NotificationException; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; import java.time.LocalDate; import java.util.HashSet; @@ -40,6 +42,8 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.argThat; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.times; @@ -66,6 +70,9 @@ class CaseworkerPostponeHearingTest { @Mock private HearingPostponedNotification hearingPostponedNotification; + @Mock + private TaskManagementService taskManagementService; + @InjectMocks private PostponeHearingNotifyParties postponeHearingNotifyParties; @@ -80,10 +87,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_POSTPONE_HEARING); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -166,6 +169,13 @@ void shouldSuccessfullyPostpone() { verify(hearingPostponedNotification, times(1)).sendToSubject(caseData, caseData.getHyphenatedCaseRef()); verify(hearingPostponedNotification, times(1)).sendToRespondent(caseData, caseData.getHyphenatedCaseRef()); verify(hearingPostponedNotification, times(1)).sendToRepresentative(caseData, caseData.getHyphenatedCaseRef()); + + verify(taskManagementService).enqueueCancellationTasks( + argThat(taskTypes -> taskTypes.containsAll( + Set.of(TaskType.completeHearingOutcome, TaskType.stitchCollateHearingBundle) + ) && taskTypes.size() == 2), + eq(TEST_CASE_ID) + ); } @ParameterizedTest diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListingTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListingTest.java index 572a533a26..b6c108aa3c 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListingTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerRecordListingTest.java @@ -84,10 +84,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_RECORD_LISTING); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrderTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrderTest.java index c82c39ec24..40d3d2d2c8 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrderTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/CaseworkerSendOrderTest.java @@ -37,6 +37,7 @@ import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; import uk.gov.hmcts.sptribs.document.model.CICDocument; import uk.gov.hmcts.sptribs.notification.dispatcher.NewOrderIssuedNotification; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import java.time.LocalDate; import java.util.ArrayList; @@ -47,11 +48,15 @@ import static java.lang.String.format; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyList; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.COLON; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.DOUBLE_HYPHEN; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.DRAFT; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.SENT; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.SOLICITOR_ADDRESS; @@ -77,6 +82,9 @@ class CaseworkerSendOrderTest { @Mock private NewOrderIssuedNotification newOrderIssuedNotification; + @Mock + private TaskManagementService taskManagementService; + @Mock private SendOrderOrderDueDates orderDueDates; @@ -91,10 +99,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CASEWORKER_SEND_ORDER); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -154,6 +158,7 @@ void shouldSuccessfullySendOrderWithEmail() { final CaseDetails updatedCaseDetails = new CaseDetails<>(); final CaseDetails beforeDetails = new CaseDetails<>(); updatedCaseDetails.setData(caseData); + updatedCaseDetails.setState(State.CaseManagement); updatedCaseDetails.setId(TEST_CASE_ID); updatedCaseDetails.setCreatedDate(LOCAL_DATE_TIME); @@ -168,6 +173,8 @@ void shouldSuccessfullySendOrderWithEmail() { final Order order = response.getData().getCicCase().getOrderList().getFirst().getValue(); assertThat(order.getDueDateList().getFirst().getValue().getDueDate()).isNotNull(); assertThat(order.getUploadedFile()).isNotNull(); + verify(taskManagementService).enqueueCompletionTasks(anyList(), eq(TEST_CASE_ID)); + verify(taskManagementService).enqueueInitiationTasks(List.of(followUpNoncomplianceOfDirections), caseData, TEST_CASE_ID); } @Test @@ -632,6 +639,7 @@ void shouldSetSendOrderTemplatesFromSelectedDraftOrder() { .cicCase(cicCase) .build(); caseDetails.setData(caseData); + caseDetails.setId(TEST_CASE_ID); // When final AboutToStartOrSubmitResponse response = caseworkerSendOrder.aboutToSubmit(caseDetails, caseDetails); diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagementTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagementTest.java index 203250640a..2805335d75 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagementTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/RespondentDocumentManagementTest.java @@ -18,13 +18,18 @@ import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; import uk.gov.hmcts.sptribs.common.service.AuditEventService; import uk.gov.hmcts.sptribs.document.model.DocumentType; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.RESPONDENT_DOCUMENT_MANAGEMENT; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @@ -42,6 +47,9 @@ class RespondentDocumentManagementTest { @Mock private AuditEventService auditEventService; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { @@ -53,10 +61,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(RESPONDENT_DOCUMENT_MANAGEMENT); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -99,6 +103,7 @@ void shouldSuccessfullyAddDocumentInAboutToSubmit() { .getCaseworkerCICDocument().getFirst().getValue().getDocumentLink().getFilename()) .isEqualTo("file.pdf"); assertThat(response.getData().getAllDocManagement().getCaseworkerCICDocument().getFirst().getValue().getDate()).isNotNull(); + verify(taskManagementService).enqueueInitiationTasks(List.of(processFurtherEvidence), caseData, TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/page/DraftOrderFooterTest.java b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/page/DraftOrderFooterTest.java index 3498a9d67d..dc456d06c3 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/page/DraftOrderFooterTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/caseworker/event/page/DraftOrderFooterTest.java @@ -11,10 +11,11 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import java.text.SimpleDateFormat; -import java.util.Calendar; import java.util.Locale; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -35,14 +36,23 @@ void shouldAddFooterSuccessfully() { CaseData caseData = CaseData.builder().build(); caseDetails.setData(caseData); - Calendar calendar = Calendar.getInstance(); - String date = simpleDateFormat.format(calendar.getTime()); - - when(orderService.generateOrderFile(caseDetails.getData(), caseDetails.getId(), date)).thenReturn(caseData); + when(orderService.generateOrderFile(eq(caseDetails.getData()), eq(caseDetails.getId()), anyString())) + .thenReturn(caseData); var response = draftOrderFooter.midEvent(caseDetails, caseDetails); assertThat(response.getData()).isEqualTo(caseData); - verify(orderService).generateOrderFile(caseDetails.getData(), caseDetails.getId(), date); + verify(orderService).generateOrderFile( + eq(caseDetails.getData()), + eq(caseDetails.getId()), + org.mockito.ArgumentMatchers.argThat(date -> { + try { + simpleDateFormat.parse(date); + return true; + } catch (Exception e) { + return false; + } + }) + ); } } diff --git a/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicDssUpdateCaseEventTest.java b/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicDssUpdateCaseEventTest.java index e65a722a54..e3ddb94fae 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicDssUpdateCaseEventTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicDssUpdateCaseEventTest.java @@ -23,6 +23,7 @@ import uk.gov.hmcts.sptribs.idam.IdamService; import uk.gov.hmcts.sptribs.notification.dispatcher.DssUpdateCaseSubmissionNotification; import uk.gov.hmcts.sptribs.notification.exception.NotificationException; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import uk.gov.hmcts.sptribs.testutil.TestDataHelper; import java.time.LocalDate; @@ -37,6 +38,7 @@ import static uk.gov.hmcts.sptribs.caseworker.util.EventConstants.CITIZEN_DSS_UPDATE_CASE_SUBMISSION; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.document.model.DocumentType.DSS_TRIBUNAL_FORM; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processFurtherEvidence; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_AUTHORIZATION_TOKEN; @@ -55,6 +57,9 @@ class CicDssUpdateCaseEventTest { @Mock private IdamService idamService; + @Mock + private TaskManagementService taskManagementService; + @InjectMocks private CicDssUpdateCaseEvent cicDssUpdateCaseEvent; @@ -69,10 +74,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(CITIZEN_DSS_UPDATE_CASE_SUBMISSION); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -112,6 +113,7 @@ void shouldAddDocumentsAndMessagesToCaseDataInAboutToSubmitCallback() { final CaseDetails details = new CaseDetails<>(); details.setData(caseData); + details.setId(TEST_CASE_ID); when(request.getHeader(AUTHORIZATION)).thenReturn(TEST_AUTHORIZATION_TOKEN); when(idamService.retrieveUser(TEST_AUTHORIZATION_TOKEN)).thenReturn(TestDataHelper.getUser()); @@ -128,6 +130,7 @@ void shouldAddDocumentsAndMessagesToCaseDataInAboutToSubmitCallback() { assertThat(response.getData().getMessages()).hasSize(2); assertThat(response.getData().getDssCaseData().getOtherInfoDocuments()).isEmpty(); assertThat(response.getData().getDssCaseData().getAdditionalInformation()).isNull(); + verify(taskManagementService).enqueueInitiationTasks(List.of(processFurtherEvidence), response.getData(), TEST_CASE_ID); } @Test @@ -159,6 +162,7 @@ void shouldAddDocumentsOnlyToCaseDataInAboutToSubmitCallbackIfAdditionalInfoFiel final CaseDetails details = new CaseDetails<>(); details.setData(caseData); + details.setId(TEST_CASE_ID); AboutToStartOrSubmitResponse response = cicDssUpdateCaseEvent.aboutToSubmit(details, details); @@ -203,6 +207,7 @@ void shouldAddDocumentsOnlyToCaseDataInAboutToSubmitCallbackIfAdditionalInfoFiel final CaseDetails details = new CaseDetails<>(); details.setData(caseData); + details.setId(TEST_CASE_ID); AboutToStartOrSubmitResponse response = cicDssUpdateCaseEvent.aboutToSubmit(details, details); @@ -232,6 +237,7 @@ void shouldCreateNewApplicantDocumentsUploadedAndMessagesListIfEmptyInAboutToSub final CaseDetails details = new CaseDetails<>(); details.setData(caseData); + details.setId(TEST_CASE_ID); when(request.getHeader(AUTHORIZATION)).thenReturn(TEST_AUTHORIZATION_TOKEN); when(idamService.retrieveUser(TEST_AUTHORIZATION_TOKEN)).thenReturn(TestDataHelper.getUser()); diff --git a/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEventTest.java b/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEventTest.java index 677f00ac06..5979b80878 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEventTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/citizen/event/CicSubmitCaseEventTest.java @@ -32,6 +32,7 @@ import uk.gov.hmcts.sptribs.document.model.DocumentType; import uk.gov.hmcts.sptribs.idam.IdamService; import uk.gov.hmcts.sptribs.notification.exception.NotificationException; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; import uk.gov.hmcts.sptribs.testutil.TestDataHelper; import uk.gov.hmcts.sptribs.util.AppsUtil; @@ -47,6 +48,7 @@ import static org.mockito.Mockito.when; import static org.springframework.http.HttpHeaders.AUTHORIZATION; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.registerNewCase; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; import static uk.gov.hmcts.sptribs.testutil.TestConstants.CASE_DATA_CIC_ID; @@ -84,6 +86,9 @@ class CicSubmitCaseEventTest { @Mock private IdamService idamService; + @Mock + private TaskManagementService taskManagementService; + private AutoCloseable autoCloseableMocks; @BeforeEach @@ -116,10 +121,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .contains(AppsUtil.getExactAppsDetailsByCaseType(appsConfig, CommonConstants.ST_CIC_CASE_TYPE).getEventIds() .getSubmitEvent()); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -256,6 +257,7 @@ void shouldUpdateCaseDetails() { assertThat(response.getData().getRepresentativeFlags().getPartyName()).isEqualTo(TEST_SOLICITOR_NAME); assertThat(response.getData().getRepresentativeFlags().getRoleOnCase()).isEqualTo("Representative"); assertThat(response.getData().getCaseNameHmctsInternal()).isEqualTo(TEST_FIRST_NAME); + verify(taskManagementService).enqueueInitiationTasks(List.of(registerNewCase), response.getData(), TEST_CASE_ID); } @Test diff --git a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskCompletionTest.java b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskCompletionTest.java deleted file mode 100644 index 9e4423c50d..0000000000 --- a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskCompletionTest.java +++ /dev/null @@ -1,648 +0,0 @@ -package uk.gov.hmcts.sptribs.dmn; - -import org.camunda.bpm.dmn.engine.DmnDecisionTableResult; -import org.camunda.bpm.dmn.engine.impl.DmnDecisionTableImpl; -import org.camunda.bpm.engine.variable.VariableMap; -import org.camunda.bpm.engine.variable.impl.VariableMapImpl; -import org.hamcrest.MatcherAssert; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; -import uk.gov.hmcts.sptribs.DmnDecisionTableBaseUnitTest; - -import java.util.Collections; -import java.util.List; -import java.util.Map; -import java.util.stream.Stream; - -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static uk.gov.hmcts.sptribs.DmnDecisionTable.WA_TASK_COMPLETION_ST_CIC_CRIMINALINJURIESCOMPENSATION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.AUTO_COMPLETE_MODE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.COMPLETE_HEARING_OUTCOME_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.CREATE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_CASE_TO_RESPONDENT_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CORRECTIONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_FURTHER_EVIDENCE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_OTHER_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_POSTPONEMENT_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_SET_ASIDE_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STRIKE_OUT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_TIME_EXT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_WRITTEN_REASONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REGISTER_NEW_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_CORRECTIONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SET_ASIDE_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WRITTEN_REASONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.STITCH_COLLATE_HEARING_BUNDLE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.VET_NEW_CASE_DOCUMENTS_TASK; - -class CamundaTaskCompletionTest extends DmnDecisionTableBaseUnitTest { - @BeforeAll - public static void initialization() { - CURRENT_DMN_DECISION_TABLE = WA_TASK_COMPLETION_ST_CIC_CRIMINALINJURIESCOMPENSATION; - } - - static Stream scenarioProvider() { - - return Stream.of( - Arguments.of( - "caseworker-send-order", - List.of( - Map.of( - "taskType", PROCESS_CASE_WITHDRAWAL_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_RULE27_DECISION_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_RULE27_DECISION_LISTED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_LISTING_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_LISTING_DIR_LISTED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_DIR_RELISTED_CASE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_SET_ASIDE_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_CORRECTIONS_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_DIR_RETURNED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_POSTPONEMENT_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_TIME_EXT_DIR_RETURNED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_OTHER_DIR_RETURNED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_WRITTEN_REASONS_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_STRIKE_OUT_DIR_RETURNED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_STAY_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_STAY_DIR_LISTED_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", ISSUE_DUE_DATE, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "caseworker-issue-final-decision", - List.of( - Map.of( - "taskType", ISSUE_DECISION_NOTICE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "caseworker-issue-decision", - List.of( - Map.of( - "taskType", ISSUE_DECISION_NOTICE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "create-hearing-summary", - List.of( - Map.of( - "taskType", COMPLETE_HEARING_OUTCOME_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "refer-to-judge", - List.of( - Map.of( - "taskType", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_FURTHER_EVIDENCE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "refer-to-legal-officer", - List.of( - Map.of( - "taskType", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_FURTHER_EVIDENCE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "caseworker-issue-case", - List.of( - Map.of( - "taskType", ISSUE_CASE_TO_RESPONDENT_TASK, - "completionMode", AUTO_COMPLETE_MODE - ) - ) - ), - Arguments.of( - "caseworker-case-built", - List.of( - Map.of( - "taskType", VET_NEW_CASE_DOCUMENTS_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "create-draft-order", - List.of( - Map.of( - "taskType", REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_TIME_EXT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STRIKE_OUT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_OTHER_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_POSTPONEMENT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_REINSTATEMENT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_POSTPONEMENT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_CORRECTIONS_REQ_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WRITTEN_REASONS_REQ_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_REINSTATEMENT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_SET_ASIDE_REQ_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_OTHER_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STRIKE_OUT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_TIME_EXT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", CREATE_DUE_DATE, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "create-and-send-order", - List.of( - Map.of( - "taskType", REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_TIME_EXT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STRIKE_OUT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_OTHER_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_POSTPONEMENT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_REINSTATEMENT_REQ_LO_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_POSTPONEMENT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_CORRECTIONS_REQ_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WRITTEN_REASONS_REQ_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_REINSTATEMENT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_SET_ASIDE_REQ_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_OTHER_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_LIST_CASE_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_STRIKE_OUT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", REVIEW_TIME_EXT_REQ_JUDGE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "edit-case", - List.of( - Map.of( - "taskType", REGISTER_NEW_CASE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_FURTHER_EVIDENCE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "caseworker-amend-document", - List.of( - Map.of( - "taskType", PROCESS_FURTHER_EVIDENCE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "contact-parties", - List.of( - Map.of( - "taskType", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Map.of( - "taskType", PROCESS_FURTHER_EVIDENCE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "createBundle", - List.of( - Map.of( - "taskType", STITCH_COLLATE_HEARING_BUNDLE_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "caseworker-document-management", - List.of( - Map.of( - "taskType", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ), - Arguments.of( - "caseworker-amend-due-date", - List.of( - Map.of( - "taskType", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "completionMode", AUTO_COMPLETE_MODE - ), - Collections.emptyMap() - ) - ) - ); - } - - @Test - void if_this_test_fails_needs_updating_with_your_changes() { - //The purpose of this test is to prevent adding new rows without being tested - DmnDecisionTableImpl logic = (DmnDecisionTableImpl) decision.getDecisionLogic(); - assertThat(logic.getInputs().size(), is(1)); - assertThat(logic.getOutputs().size(), is(2)); - assertThat(logic.getRules().size(), is(100)); - } - - @ParameterizedTest(name = "event id: {0}") - @MethodSource("scenarioProvider") - void given_event_ids_should_evaluate_dmn(String eventId, List> expectation) { - - VariableMap inputVariables = new VariableMapImpl(); - inputVariables.putValue("eventId", eventId); - - DmnDecisionTableResult dmnDecisionTableResult = evaluateDmnTable(inputVariables); - MatcherAssert.assertThat(dmnDecisionTableResult.getResultList(), is(expectation)); - } - -} diff --git a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskTypesTest.java b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskTypesTest.java index 88f6f8260c..c8b119d9d2 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskTypesTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskTypesTest.java @@ -19,75 +19,10 @@ import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; import static uk.gov.hmcts.sptribs.DmnDecisionTable.WA_TASK_TYPES_ST_CIC_CRIMINALINJURIESCOMPENSATION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.COMPLETE_HEARING_OUTCOME_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.CREATE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_CASE_TO_RESPONDENT_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CORRECTIONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_FURTHER_EVIDENCE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_OTHER_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_POSTPONEMENT_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_SET_ASIDE_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STRIKE_OUT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_TIME_EXT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_WRITTEN_REASONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REGISTER_NEW_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_CORRECTIONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_ORDER; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SET_ASIDE_REQ_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_ADMIN_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_CTSC_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_JUDICIARY_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WRITTEN_REASONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.STITCH_COLLATE_HEARING_BUNDLE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.VET_NEW_CASE_DOCUMENTS_TASK; class CamundaTaskTypesTest extends DmnDecisionTableBaseUnitTest { @@ -98,254 +33,6 @@ public static void initialization() { static Stream scenarioProvider() { List> taskTypes = List.of( - Map.of( - "taskTypeId", PROCESS_CASE_WITHDRAWAL_DIR_TASK, - "taskTypeName", "Process case withdrawal directions" - ), - Map.of( - "taskTypeId", PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK, - "taskTypeName", "Process case withdrawal directions listed" - ), - Map.of( - "taskTypeId", PROCESS_RULE27_DECISION_TASK, - "taskTypeName", "Process Rule 27 decision" - ), - Map.of( - "taskTypeId", PROCESS_RULE27_DECISION_LISTED_TASK, - "taskTypeName", "Process Rule 27 decision listed" - ), - Map.of( - "taskTypeId", PROCESS_LISTING_DIR_TASK, - "taskTypeName", "Process listing directions" - ), - Map.of( - "taskTypeId", PROCESS_LISTING_DIR_LISTED_TASK, - "taskTypeName", "Process listing directions listed" - ), - Map.of( - "taskTypeId", PROCESS_DIR_RELISTED_CASE_TASK, - "taskTypeName", "Process directions re. listed case" - ), - Map.of( - "taskTypeId", PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK, - "taskTypeName", "Process directions re. listed case (within 5 days)" - ), - Map.of( - "taskTypeId", PROCESS_SET_ASIDE_DIR_TASK, - "taskTypeName", "Process set aside directions" - ), - Map.of( - "taskTypeId", PROCESS_CORRECTIONS_TASK, - "taskTypeName", "Process corrections" - ), - Map.of( - "taskTypeId", PROCESS_DIR_RETURNED_TASK, - "taskTypeName", "Process directions returned" - ), - Map.of( - "taskTypeId", PROCESS_POSTPONEMENT_DIR_TASK, - "taskTypeName", "Process postponement directions" - ), - Map.of( - "taskTypeId", PROCESS_TIME_EXT_DIR_RETURNED_TASK, - "taskTypeName", "Process time extension directions returned" - ), - Map.of( - "taskTypeId", PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK, - "taskTypeName", "Process reinstatement decision notice" - ), - Map.of( - "taskTypeId", PROCESS_OTHER_DIR_RETURNED_TASK, - "taskTypeName", "Process other directions returned" - ), - Map.of( - "taskTypeId", PROCESS_WRITTEN_REASONS_TASK, - "taskTypeName", "Process written reasons" - ), - Map.of( - "taskTypeId", PROCESS_STRIKE_OUT_DIR_RETURNED_TASK, - "taskTypeName", "Process strike out directions returned" - ), - Map.of( - "taskTypeId", PROCESS_STAY_DIR_TASK, - "taskTypeName", "Process stay directions" - ), - Map.of( - "taskTypeId", PROCESS_STAY_DIR_LISTED_TASK, - "taskTypeName", "Process stay directions listed" - ), - Map.of( - "taskTypeId", ISSUE_DECISION_NOTICE_TASK, - "taskTypeName", "Issue decision notice" - ), - Map.of( - "taskTypeId", COMPLETE_HEARING_OUTCOME_TASK, - "taskTypeName", "Complete hearing outcome" - ), - Map.of( - "taskTypeId", ISSUE_CASE_TO_RESPONDENT_TASK, - "taskTypeName", "Issue case to respondent" - ), - Map.of( - "taskTypeId", VET_NEW_CASE_DOCUMENTS_TASK, - "taskTypeName", "Vet new case documents" - ), - Map.of( - "taskTypeId", REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK, - "taskTypeName", "Review new case and provide directions - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_TIME_EXT_REQ_LO_TASK, - "taskTypeName", "Review time extension request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_STRIKE_OUT_REQ_LO_TASK, - "taskTypeName", "Review strike out request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_STAY_REQ_LO_TASK, - "taskTypeName", "Review stay request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_STAY_REQ_CASE_LISTED_LO_TASK, - "taskTypeName", "Review stay request case listed - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_LISTING_DIR_LO_TASK, - "taskTypeName", "Review listing directions - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK, - "taskTypeName", "Review listing directions case listed - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_WITHDRAWAL_REQ_LO_TASK, - "taskTypeName", "Review withdrawal request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK, - "taskTypeName", "Review withdrawal request case listed - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_RULE27_REQ_LO_TASK, - "taskTypeName", "Review Rule 27 request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK, - "taskTypeName", "Review Rule 27 request case listed - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_LIST_CASE_LO_TASK, - "taskTypeName", "Review list case - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_OTHER_REQ_LO_TASK, - "taskTypeName", "Review reinstatement request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK, - "taskTypeName", "Review list case (within 5 days) - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_POSTPONEMENT_REQ_LO_TASK, - "taskTypeName", "Review postponement request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_REINSTATEMENT_REQ_LO_TASK, - "taskTypeName", "Review reinstatement request - Legal Officer" - ), - Map.of( - "taskTypeId", REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK, - "taskTypeName", "Review list case (within 5 days) - Judge" - ), - Map.of( - "taskTypeId", REVIEW_POSTPONEMENT_REQ_JUDGE_TASK, - "taskTypeName", "Review postponement request - Judge" - ), - Map.of( - "taskTypeId", REVIEW_CORRECTIONS_REQ_TASK, - "taskTypeName", "Review corrections request" - ), - Map.of( - "taskTypeId", REVIEW_WRITTEN_REASONS_REQ_TASK, - "taskTypeName", "Review written reasons request" - ), - Map.of( - "taskTypeId", REVIEW_REINSTATEMENT_REQ_JUDGE_TASK, - "taskTypeName", "Review reinstatement request - Judge" - ), - Map.of( - "taskTypeId", REVIEW_SET_ASIDE_REQ_TASK, - "taskTypeName", "Review set aside request" - ), - Map.of( - "taskTypeId", REVIEW_STAY_REQ_JUDGE_TASK, - "taskTypeName", "Review stay request - Judge" - ), - Map.of( - "taskTypeId", REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK, - "taskTypeName", "Review stay request case listed - Judge" - ), - Map.of( - "taskTypeId", REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK, - "taskTypeName", "Review new case and provide directions - Judge" - ), - Map.of( - "taskTypeId", REVIEW_OTHER_REQ_JUDGE_TASK, - "taskTypeName", "Review other request - Judge" - ), - Map.of( - "taskTypeId", REVIEW_WITHDRAWAL_REQ_JUDGE_TASK, - "taskTypeName", "Review withdrawal request - Judge" - ), - Map.of( - "taskTypeId", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK, - "taskTypeName", "Review withdrawal request case listed - Judge" - ), - Map.of( - "taskTypeId", REVIEW_RULE27_REQ_JUDGE_TASK, - "taskTypeName", "Review Rule 27 request - Judge" - ), - Map.of( - "taskTypeId", REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK, - "taskTypeName", "Review Rule 27 request case listed - Judge" - ), - Map.of( - "taskTypeId", REVIEW_LISTING_DIR_JUDGE_TASK, - "taskTypeName", "Review listing directions - Judge" - ), - Map.of( - "taskTypeId", REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK, - "taskTypeName", "Review listing directions case listed - Judge" - ), - Map.of( - "taskTypeId", REVIEW_LIST_CASE_JUDGE_TASK, - "taskTypeName", "Review list case - Judge" - ), - Map.of( - "taskTypeId", REVIEW_STRIKE_OUT_REQ_JUDGE_TASK, - "taskTypeName", "Review strike out request - Judge" - ), - Map.of( - "taskTypeId", REVIEW_TIME_EXT_REQ_JUDGE_TASK, - "taskTypeName", "Review time extension request - Judge" - ), - Map.of( - "taskTypeId", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "taskTypeName", "Follow up noncompliance of directions" - ), - Map.of( - "taskTypeId", REGISTER_NEW_CASE_TASK, - "taskTypeName", "Register new case" - ), - Map.of( - "taskTypeId", PROCESS_FURTHER_EVIDENCE_TASK, - "taskTypeName", "Process further evidence" - ), - Map.of( - "taskTypeId", STITCH_COLLATE_HEARING_BUNDLE_TASK, - "taskTypeName", "Stitch/collate hearing bundle" - ), Map.of( "taskTypeId", REVIEW_SPECIFIC_ACCESS_REQ_JUDICIARY_TASK, "taskTypeName", "Review Specific Access Request Judiciary" @@ -361,18 +48,6 @@ static Stream scenarioProvider() { Map.of( "taskTypeId", REVIEW_SPECIFIC_ACCESS_REQ_CTSC_TASK, "taskTypeName", "Review Specific Access Request CTSC" - ), - Map.of( - "taskTypeId", CREATE_DUE_DATE, - "taskTypeName", "Create due date" - ), - Map.of( - "taskTypeId", ISSUE_DUE_DATE, - "taskTypeName", "Issue due date" - ), - Map.of( - "taskTypeId", REVIEW_ORDER, - "taskTypeName", "Review Order" ) ); return Stream.of( @@ -388,7 +63,7 @@ void check_dmn_changed() { DmnDecisionTableImpl logic = (DmnDecisionTableImpl) decision.getDecisionLogic(); assertThat(logic.getInputs().size(), is(1)); assertThat(logic.getOutputs().size(), is(2)); - assertThat(logic.getRules().size(), is(69)); + assertThat(logic.getRules().size(), is(4)); } @ParameterizedTest(name = "retrieve all task type data") diff --git a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaCancellationTest.java b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaCancellationTest.java deleted file mode 100644 index a695856817..0000000000 --- a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaCancellationTest.java +++ /dev/null @@ -1,79 +0,0 @@ -package uk.gov.hmcts.sptribs.dmn; - -import org.camunda.bpm.dmn.engine.DmnDecisionTableResult; -import org.camunda.bpm.dmn.engine.impl.DmnDecisionTableImpl; -import org.camunda.bpm.engine.variable.VariableMap; -import org.camunda.bpm.engine.variable.impl.VariableMapImpl; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; -import uk.gov.hmcts.sptribs.DmnDecisionTableBaseUnitTest; - -import java.util.List; -import java.util.Map; -import java.util.stream.Stream; - -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static uk.gov.hmcts.sptribs.DmnDecisionTable.WA_TASK_CANCELLATION_ST_CIC_CRIMINALINJURIESCOMPENSATION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_HEARING_BUNDLE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_HEARING_COMPLETION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_ISSUE_CASE; -import static uk.gov.hmcts.sptribs.dmnutils.CancellationScenarioBuilder.event; - -class CamundaTaskWaCancellationTest extends DmnDecisionTableBaseUnitTest { - - @BeforeAll - public static void initialization() { - CURRENT_DMN_DECISION_TABLE = WA_TASK_CANCELLATION_ST_CIC_CRIMINALINJURIESCOMPENSATION; - } - - public static Stream scenarioProvider() { - return Stream.of( - event("caseworker-close-the-case") - .cancelAll() - .build(), - event("caseworker-postpone-hearing") - .cancel(PROCESS_CATEGORY_HEARING_COMPLETION) - .cancel(PROCESS_CATEGORY_HEARING_BUNDLE) - .build(), - event("caseworker-cancel-hearing") - .cancel(PROCESS_CATEGORY_HEARING_COMPLETION) - .cancel(PROCESS_CATEGORY_HEARING_BUNDLE) - .build(), - event("refer-to-judge") - .cancel(PROCESS_CATEGORY_ISSUE_CASE) - .build(), - event("refer-to-legal-officer") - .cancel(PROCESS_CATEGORY_ISSUE_CASE) - .build() - ); - } - - @Test - void if_this_test_fails_needs_updating_with_your_changes() { - //The purpose of this test is to prevent adding new rows without being tested - DmnDecisionTableImpl logic = (DmnDecisionTableImpl) decision.getDecisionLogic(); - assertThat(logic.getInputs().size(), is(3)); - assertThat(logic.getOutputs().size(), is(4)); - assertThat(logic.getRules().size(), is(4)); - } - - @ParameterizedTest(name = "from state: {0}, event id: {1}, state: {2}") - @MethodSource("scenarioProvider") - void given_multiple_event_ids_should_evaluate_dmn(String fromState, - String eventId, - String state, - List> expectedDmnOutcome) { - VariableMap inputVariables = new VariableMapImpl(); - inputVariables.putValue("fromState", fromState); - inputVariables.putValue("event", eventId); - inputVariables.putValue("state", state); - - DmnDecisionTableResult dmnDecisionTableResult = evaluateDmnTable(inputVariables); - assertThat(dmnDecisionTableResult.getResultList(), is(expectedDmnOutcome)); - } - -} diff --git a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaConfigurationTest.java b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaConfigurationTest.java index 8e4b2a7635..2353ea7e60 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaConfigurationTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaConfigurationTest.java @@ -28,104 +28,27 @@ import static uk.gov.hmcts.sptribs.DmnDecisionTable.WA_TASK_CONFIGURATION_ST_CIC_CRIMINALINJURIESCOMPENSATION; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ACCESS_WORK_TYPE; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ADDITIONAL_PROPERTIES_ROLE_ASSIGNMENT_ID; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.APPLICATION_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.CASE_MANAGEMENT_CATEGORY; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.CASE_NAME; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.COMPLETE_HEARING_OUTCOME_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.CREATE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.DECISION_WORK_TYPE; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.DEFAULT_MAJOR_PRIORITY; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.DEFAULT_MINOR_PRIORITY; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.DESCRIPTION; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.DUE_DATE_INTERVAL_DAYS; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.DUE_DATE_ORIGIN; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.HEARING_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_CASE_TO_RESPONDENT_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.LOCATION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.LOCATION_NAME; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.MAJOR_PRIORITY; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.MINOR_PRIORITY; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PRIORITY_DATE_ORIGIN_REF; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PRIORITY_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CORRECTIONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_FURTHER_EVIDENCE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_OTHER_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_POSTPONEMENT_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_SET_ASIDE_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STRIKE_OUT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_TIME_EXT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_WRITTEN_REASONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REGION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REGISTER_NEW_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_CORRECTIONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_ORDER; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SET_ASIDE_REQ_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_ADMIN_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_CTSC_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_JUDICIARY_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WRITTEN_REASONS_REQ_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_ADMIN; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_CTSC; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_JUDICIAL; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_LO; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROUTINE_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.STITCH_COLLATE_HEARING_BUNDLE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.URGENT_MAJOR_PRIORITY; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.VET_NEW_CASE_DOCUMENTS_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.WORK_TYPE; class CamundaTaskWaConfigurationTest extends DmnDecisionTableBaseUnitTest { - private static final String REQUEST = "classpath:custom-case-data.json"; private static final String taskId = UUID.randomUUID().toString(); private static final String roleAssignmentId = UUID.randomUUID().toString(); @@ -136,1115 +59,6 @@ public static void initialization() { static Stream scenarioProvider() throws IOException { return Stream.of( - - Arguments.of( - PROCESS_CASE_WITHDRAWAL_DIR_TASK, - CaseDataBuilder.defaultCase() - .isUrgent() - .build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, URGENT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue(DESCRIPTION, "[Orders: Send order](/cases/case-details" - + "/${[CASE_REFERENCE]}/trigger/caseworker-send-order)", true) - .expectedValue(DUE_DATE_ORIGIN, ZonedDateTime.now(), false) - .build() - ), - Arguments.of( - PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK, - CaseDataBuilder.defaultCase() - .isUrgent() - .build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, URGENT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue(DESCRIPTION, "[Orders: Send order](/cases/case-details" - + "/${[CASE_REFERENCE]}/trigger/caseworker-send-order)", true) - .expectedValue(DUE_DATE_ORIGIN, ZonedDateTime.now(), false) - .build() - ), - Arguments.of( - PROCESS_RULE27_DECISION_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_RULE27_DECISION_LISTED_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_LISTING_DIR_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "3", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_LISTING_DIR_LISTED_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "3", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_DIR_RELISTED_CASE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, PRIORITY_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_SET_ASIDE_DIR_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_CORRECTIONS_TASK, - CaseDataBuilder.defaultCase() - .isUrgent() - .build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, URGENT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, HEARING_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "3", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_DIR_RETURNED_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_POSTPONEMENT_DIR_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_TIME_EXT_DIR_RETURNED_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_OTHER_DIR_RETURNED_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_WRITTEN_REASONS_TASK, - CaseDataBuilder.defaultCase() - .isUrgent() - .build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, URGENT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "3", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_STRIKE_OUT_DIR_RETURNED_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_STAY_DIR_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - PROCESS_STAY_DIR_LISTED_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Orders: Send order](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-send-order)", - true - ) - .build() - ), - Arguments.of( - ISSUE_DECISION_NOTICE_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, HEARING_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Decision: Issue a decision](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-issue-decision)
" - + "[Decision: Issue final decision](/cases/case-details/${[CASE_REFERENCE]}" - + "/trigger/caseworker-issue-final-decision)", - true - ) - .build() - ), - Arguments.of( - COMPLETE_HEARING_OUTCOME_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, HEARING_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Hearings:Create summary](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/create-hearing-summary)", - true - ) - .build() - ), - Arguments.of( - ISSUE_CASE_TO_RESPONDENT_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "2", true) - .expectedValue( - DESCRIPTION, - "[Case: Issue to respondent](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-issue-case)", - true - ) - .build() - ), - Arguments.of( - VET_NEW_CASE_DOCUMENTS_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, APPLICATION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Case: Build case](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-case-built)", - true - ) - .build() - ), - Arguments.of( - REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_TIME_EXT_REQ_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_STRIKE_OUT_REQ_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_STAY_REQ_LO_TASK, - CaseDataBuilder.defaultCase() - .isUrgent() - .build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, URGENT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_STAY_REQ_CASE_LISTED_LO_TASK, - CaseDataBuilder.defaultCase() - .isUrgent() - .build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, URGENT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LISTING_DIR_LO_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_RULE27_REQ_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LIST_CASE_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_OTHER_REQ_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_POSTPONEMENT_REQ_LO_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_REINSTATEMENT_REQ_LO_TASK, - CaseDataBuilder.defaultCase() - .isUrgent() - .build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, URGENT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_LO, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_POSTPONEMENT_REQ_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_CORRECTIONS_REQ_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_WRITTEN_REASONS_REQ_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "28", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_REINSTATEMENT_REQ_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_SET_ASIDE_REQ_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "2", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_STAY_REQ_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_OTHER_REQ_JUDGE_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY,true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE,true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL,true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5",true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_RULE27_REQ_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LISTING_DIR_JUDGE_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_LIST_CASE_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_STRIKE_OUT_REQ_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - REVIEW_TIME_EXT_REQ_JUDGE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_JUDICIAL, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create and send order](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-and-send-order)", - true - ) - .build() - ), - Arguments.of( - FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Document management: Upload](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-document-management)
" - + "[Orders: Manage due date](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-amend-due-date)
" - + "[Refer case to judge](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/refer-to-judge)
" - + "[Refer case to legal officer](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/refer-to-legal-officer)
" - + "[Case: Contact parties](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/contact-parties)", - true - ) - .build() - ), - Arguments.of( - REGISTER_NEW_CASE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, APPLICATION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue( - DESCRIPTION, - "[Case: Edit case](/cases/case-details/${[CASE_REFERENCE]}/trigger/edit-case)", - true - ) - .build() - ), - Arguments.of( - PROCESS_FURTHER_EVIDENCE_TASK, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "7", true) - .expectedValue( - DESCRIPTION, - "[Document management: Amend](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/caseworker-amend-document)
" - + "[Case: Edit case](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/edit-case)
" - + "[Refer case to judge](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/refer-to-judge)
" - + "[Refer case to legal officer](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/refer-to-legal-officer)
" - + "[Case: Contact parties](/cases/case-details/${[CASE_REFERENCE]}/trigger" - + "/contact-parties)", - true - ) - .build() - ), - Arguments.of( - STITCH_COLLATE_HEARING_BUNDLE_TASK, - CaseDataBuilder.customCase(REQUEST).build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(CASE_NAME, "Rio Read", true) - .expectedValue(CASE_MANAGEMENT_CATEGORY, "ST CIC", true) - .expectedValue(REGION, "123", true) - .expectedValue(LOCATION, "123456", true) - .expectedValue(LOCATION_NAME, "GTC", true) - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, HEARING_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "1", true) - .expectedValue( - DESCRIPTION, - "[Bundle: Create a bundle](/cases/case-details/${[CASE_REFERENCE]}/trigger/createBundle)", - true - ) - .build() - ), Arguments.of( REVIEW_SPECIFIC_ACCESS_REQ_JUDICIARY_TASK, CaseDataBuilder.defaultCase().build(), @@ -1312,47 +126,6 @@ static Stream scenarioProvider() throws IOException { ) .expectedValue(ADDITIONAL_PROPERTIES_ROLE_ASSIGNMENT_ID, roleAssignmentId, false) .build() - ), - Arguments.of( - CREATE_DUE_DATE, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "2", true) - .expectedValue( - DESCRIPTION, - "[Orders: Create draft](/cases/case-details/${[CASE_REFERENCE]}/trigger/create-draft-order)", - true - ) - .build() - ), - Arguments.of( - ISSUE_DUE_DATE, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, ROUTINE_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "2", true) - .expectedValue(DESCRIPTION, "[Orders: Send order](/cases/case-details" - + "/${[CASE_REFERENCE]}/trigger/caseworker-send-order)", true) - .build() - ), - Arguments.of( - REVIEW_ORDER, - CaseDataBuilder.defaultCase().build(), - ConfigurationExpectationBuilder.defaultExpectations() - .expectedValue(MINOR_PRIORITY, DEFAULT_MINOR_PRIORITY, true) - .expectedValue(MAJOR_PRIORITY, DEFAULT_MAJOR_PRIORITY, true) - .expectedValue(WORK_TYPE, DECISION_WORK_TYPE, true) - .expectedValue(ROLE_CATEGORY, ROLE_CATEGORY_ADMIN, true) - .expectedValue(DUE_DATE_INTERVAL_DAYS, "5", true) - .expectedValue(DESCRIPTION, "", true) - .build() ) ); } @@ -1363,7 +136,7 @@ void if_this_test_fails_needs_updating_with_your_changes() { DmnDecisionTableImpl logic = (DmnDecisionTableImpl) decision.getDecisionLogic(); assertThat(logic.getInputs().size(), is(2)); assertThat(logic.getOutputs().size(), is(3)); - assertEquals(45, logic.getRules().size()); + assertEquals(23, logic.getRules().size()); } @ParameterizedTest(name = "task type: {0} case data: {1}") diff --git a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaInitiationTest.java b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaInitiationTest.java deleted file mode 100644 index 80f1ad296c..0000000000 --- a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaInitiationTest.java +++ /dev/null @@ -1,1539 +0,0 @@ -package uk.gov.hmcts.sptribs.dmn; - -import org.camunda.bpm.dmn.engine.DmnDecisionTableResult; -import org.camunda.bpm.dmn.engine.impl.DmnDecisionTableImpl; -import org.camunda.bpm.engine.variable.VariableMap; -import org.camunda.bpm.engine.variable.impl.VariableMapImpl; -import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.Arguments; -import org.junit.jupiter.params.provider.MethodSource; -import uk.gov.hmcts.sptribs.DmnDecisionTableBaseUnitTest; -import uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants; -import uk.gov.hmcts.sptribs.dmnutils.DelayUntilRequest; - -import java.time.LocalDate; -import java.util.List; -import java.util.Map; -import java.util.Objects; -import java.util.stream.Stream; - -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.fail; -import static uk.gov.hmcts.sptribs.DmnDecisionTable.WA_TASK_INITIATION_ST_CIC_CRIMINALINJURIESCOMPENSATION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.APPLICATION_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.COMPLETE_HEARING_OUTCOME_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.CREATE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.DECISION_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.HEARING_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_CASE_TO_RESPONDENT_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PRIORITY_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_AMENDMENT; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_APPLICATION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_DECISION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_HEARING; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_HEARING_BUNDLE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_HEARING_COMPLETION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_ISSUE_CASE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CATEGORY_PROCESSING; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CORRECTIONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_FURTHER_EVIDENCE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_OTHER_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_POSTPONEMENT_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_SET_ASIDE_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STRIKE_OUT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_TIME_EXT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_WRITTEN_REASONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REGISTER_NEW_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_CORRECTIONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_ORDER; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SET_ASIDE_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WRITTEN_REASONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_ADMIN; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_JUDICIAL; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_LO; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROUTINE_WORK_TYPE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.STITCH_COLLATE_HEARING_BUNDLE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.VET_NEW_CASE_DOCUMENTS_TASK; - -class CamundaTaskWaInitiationTest extends DmnDecisionTableBaseUnitTest { - - private static final DelayUntilRequest DELAY_UNTIL_HOLIDAY_REQUEST = - DelayUntilRequest.builder() - .delayUntilOrigin(LocalDate.of(2026, 4, 2).toString()) - .delayUntilIntervalDays(1) - .delayUntilNonWorkingCalendar(CamundaTaskConstants.DEFAULT_DUE_DATE_NON_WORKING_CALENDAR) - .delayUntilNonWorkingDaysOfWeek(CamundaTaskConstants.DEFAULT_DUE_DATE_WORKING_DAYS_OF_WEEK) - .delayUntilSkipNonWorkingDays(false) - .delayUntilMustBeWorkingDay("Next") - .build(); - - @BeforeAll - public static void initialization() { - CURRENT_DMN_DECISION_TABLE = WA_TASK_INITIATION_ST_CIC_CRIMINALINJURIESCOMPENSATION; - } - - static Stream scenarioProvider() { - return Stream.of( - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", PROCESS_CASE_WITHDRAWAL_DIR_TASK, - "name", "Process case withdrawal directions", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", PROCESS_CASE_WITHDRAWAL_DIR_TASK, - "name", "Process case withdrawal directions", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK, - "name", "Process case withdrawal directions listed", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", PROCESS_RULE27_DECISION_TASK, - "name", "Process Rule 27 decision", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", PROCESS_RULE27_DECISION_TASK, - "name", "Process Rule 27 decision", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", PROCESS_RULE27_DECISION_LISTED_TASK, - "name", "Process Rule 27 decision listed", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listing directions")), - List.of( - Map.of( - "taskId", PROCESS_LISTING_DIR_TASK, - "name", "Process listing directions", - "workingDaysAllowed", 3, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listing directions")), - List.of( - Map.of( - "taskId", PROCESS_LISTING_DIR_LISTED_TASK, - "name", "Process listing directions listed", - "workingDaysAllowed", 3, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listed case")), - List.of( - Map.of( - "taskId", PROCESS_DIR_RELISTED_CASE_TASK, - "name", "Process directions re. listed case", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listed case (within 5 days)")), - List.of( - Map.of( - "taskId", PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK, - "name", "Process directions re. listed case (within 5 days)", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", PRIORITY_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Set aside request")), - List.of( - Map.of( - "taskId", PROCESS_SET_ASIDE_DIR_TASK, - "name", "Process set aside directions", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_DECISION, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Corrections")), - List.of( - Map.of( - "taskId", PROCESS_CORRECTIONS_TASK, - "name", "Process corrections", - "workingDaysAllowed", 3, - "processCategories", PROCESS_CATEGORY_AMENDMENT, - "workType", HEARING_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "New case")), - List.of( - Map.of( - "taskId", PROCESS_DIR_RETURNED_TASK, - "name", "Process directions returned", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "New case")), - List.of( - Map.of( - "taskId", PROCESS_DIR_RETURNED_TASK, - "name", "Process directions returned", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Postponement request")), - List.of( - Map.of( - "taskId", PROCESS_POSTPONEMENT_DIR_TASK, - "name", "Process postponement directions", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Time extension request")), - List.of( - Map.of( - "taskId", PROCESS_TIME_EXT_DIR_RETURNED_TASK, - "name", "Process time extension directions returned", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Time extension request")), - List.of( - Map.of( - "taskId", PROCESS_TIME_EXT_DIR_RETURNED_TASK, - "name", "Process time extension directions returned", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Reinstatement request")), - List.of( - Map.of( - "taskId", PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK, - "name", "Process reinstatement decision notice", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_APPLICATION, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "*", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Other")), - List.of( - Map.of( - "taskId", PROCESS_OTHER_DIR_RETURNED_TASK, - "name", "Process other directions returned", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Written reasons request")), - List.of( - Map.of( - "taskId", PROCESS_WRITTEN_REASONS_TASK, - "name", "Process written reasons", - "workingDaysAllowed", 3, - "processCategories", PROCESS_CATEGORY_DECISION, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Strike out request")), - List.of( - Map.of( - "taskId", PROCESS_STRIKE_OUT_DIR_RETURNED_TASK, - "name", "Process strike out directions returned", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Strike out request")), - List.of( - Map.of( - "taskId", PROCESS_STRIKE_OUT_DIR_RETURNED_TASK, - "name", "Process strike out directions returned", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", PROCESS_STAY_DIR_TASK, - "name", "Process stay directions", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", PROCESS_STAY_DIR_TASK, - "name", "Process stay directions", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "")), - List.of( - Map.of( - "taskId", ISSUE_DUE_DATE, - "name", "Issue due date", - "workingDaysAllowed", 2, - "processCategories", PROCESS_CATEGORY_ISSUE_CASE, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-draft-order", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", PROCESS_STAY_DIR_LISTED_TASK, - "name", "Process stay directions listed", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-hearing-summary", - "AwaitingOutcome", - null, - List.of( - Map.of( - "taskId", ISSUE_DECISION_NOTICE_TASK, - "name", "Issue decision notice", - "workingDaysAllowed", 1, - "workType", HEARING_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "system-trigger-stitch-collate-hearing-bundle", - "AwaitingHearing", - null, - List.of( - Map.of( - "taskId", STITCH_COLLATE_HEARING_BUNDLE_TASK, - "name", "Stitch/collate hearing bundle", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING_BUNDLE, - "workType", HEARING_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "system-trigger-complete-hearing-outcome", - "AwaitingHearing", - null, - List.of( - Map.of( - "taskId", COMPLETE_HEARING_OUTCOME_TASK, - "name", "Complete hearing outcome", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_HEARING_COMPLETION, - "workType", HEARING_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "caseworker-case-built", - "CaseManagement", - null, - List.of( - Map.of( - "taskId", ISSUE_CASE_TO_RESPONDENT_TASK, - "name", "Issue case to respondent", - "workingDaysAllowed", 2, - "processCategories", PROCESS_CATEGORY_ISSUE_CASE, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "edit-case", - "Submitted", - null, - List.of( - Map.of( - "taskId", VET_NEW_CASE_DOCUMENTS_TASK, - "name", "Vet new case documents", - "workingDaysAllowed", 5, - "workType", APPLICATION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "citizen-cic-submit-dss-application", - "DSS_Submitted", - null, - List.of( - Map.of( - "taskId", REGISTER_NEW_CASE_TASK, - "name", "Register new case", - "workingDaysAllowed", 5, - "workType", APPLICATION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "New case")), - List.of( - Map.of( - "taskId", REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK, - "name", "Review new case and provide directions - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "New case")), - List.of( - Map.of( - "taskId", REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK, - "name", "Review new case and provide directions - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Time extension request")), - List.of( - Map.of( - "taskId", REVIEW_TIME_EXT_REQ_LO_TASK, - "name", "Review time extension request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Time extension request")), - List.of( - Map.of( - "taskId", REVIEW_TIME_EXT_REQ_LO_TASK, - "name", "Review time extension request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Strike out request")), - List.of( - Map.of( - "taskId", REVIEW_STRIKE_OUT_REQ_LO_TASK, - "name", "Review strike out request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Strike out request")), - List.of( - Map.of( - "taskId", REVIEW_STRIKE_OUT_REQ_LO_TASK, - "name", "Review strike out request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", REVIEW_STAY_REQ_LO_TASK, - "name", "Review stay request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", REVIEW_STAY_REQ_LO_TASK, - "name", "Review stay request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", REVIEW_STAY_REQ_CASE_LISTED_LO_TASK, - "name", "Review stay request case listed - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listing directions")), - List.of( - Map.of( - "taskId", REVIEW_LISTING_DIR_LO_TASK, - "name", "Review listing directions - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listing directions")), - List.of( - Map.of( - "taskId", REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK, - "name", "Review listing directions case listed - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", REVIEW_WITHDRAWAL_REQ_LO_TASK, - "name", "Review withdrawal request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", REVIEW_WITHDRAWAL_REQ_LO_TASK, - "name", "Review withdrawal request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK, - "name", "Review withdrawal request case listed - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", REVIEW_RULE27_REQ_LO_TASK, - "name", "Review Rule 27 request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", REVIEW_RULE27_REQ_LO_TASK, - "name", "Review Rule 27 request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK, - "name", "Review Rule 27 request case listed - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listed case")), - List.of( - Map.of( - "taskId", REVIEW_LIST_CASE_LO_TASK, - "name", "Review list case - Legal Officer", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listed case (within 5 days)")), - List.of( - Map.of( - "taskId", REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK, - "name", "Review list case (within 5 days) - Legal Officer", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Postponement request")), - List.of( - Map.of( - "taskId", REVIEW_POSTPONEMENT_REQ_LO_TASK, - "name", "Review postponement request - Legal Officer", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Reinstatement request")), - List.of( - Map.of( - "name", "Review reinstatement request - Legal Officer", - "workType", DECISION_WORK_TYPE, - "taskId", REVIEW_REINSTATEMENT_REQ_LO_TASK, - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_APPLICATION, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-legal-officer", - "*", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Other")), - List.of( - Map.of( - "taskId", REVIEW_OTHER_REQ_LO_TASK, - "name", "Review other request - Legal Officer", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_LO - ) - ) - ), - Arguments.of( - "refer-to-judge", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listed case (within 5 days)")), - List.of( - Map.of( - "taskId", REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK, - "name", "Review list case (within 5 days) - Judge", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Postponement request")), - List.of( - Map.of( - "taskId", REVIEW_POSTPONEMENT_REQ_JUDGE_TASK, - "name", "Review postponement request - Judge", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Corrections")), - List.of( - Map.of( - "taskId", REVIEW_CORRECTIONS_REQ_TASK, - "name", "Review corrections request", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_AMENDMENT, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Written reasons request")), - List.of( - Map.of( - "taskId", REVIEW_WRITTEN_REASONS_REQ_TASK, - "name", "Review written reasons request", - "workingDaysAllowed", 28, - "processCategories", PROCESS_CATEGORY_DECISION, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Reinstatement request")), - List.of( - Map.of( - "taskId", REVIEW_REINSTATEMENT_REQ_JUDGE_TASK, - "name", "Review reinstatement request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_APPLICATION, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseClosed", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Set aside request")), - List.of( - Map.of( - "taskId", REVIEW_SET_ASIDE_REQ_TASK, - "name", "Review set aside request", - "workingDaysAllowed", 2, - "processCategories", PROCESS_CATEGORY_DECISION, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", REVIEW_STAY_REQ_JUDGE_TASK, - "name", "Review stay request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", REVIEW_STAY_REQ_JUDGE_TASK, - "name", "Review stay request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Stay request")), - List.of( - Map.of( - "taskId", REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK, - "name", "Review stay request case listed - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "New case")), - List.of( - Map.of( - "taskId", REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK, - "name", "Review new case and provide directions - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "New case")), - List.of( - Map.of( - "taskId", REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK, - "name", "Review new case and provide directions - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "*", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Other")), - List.of( - Map.of( - "taskId", REVIEW_OTHER_REQ_JUDGE_TASK, - "name", "Review other request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", REVIEW_WITHDRAWAL_REQ_JUDGE_TASK, - "name", "Review withdrawal request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", REVIEW_WITHDRAWAL_REQ_JUDGE_TASK, - "name", "Review withdrawal request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Withdrawal request")), - List.of( - Map.of( - "taskId", REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK, - "name", "Review withdrawal request case listed - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", REVIEW_RULE27_REQ_JUDGE_TASK, - "name", "Review Rule 27 request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", REVIEW_RULE27_REQ_JUDGE_TASK, - "name", "Review Rule 27 request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Rule 27 request")), - List.of( - Map.of( - "taskId", REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK, - "name", "Review Rule 27 request case listed - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listing directions")), - List.of( - Map.of( - "taskId", REVIEW_LISTING_DIR_JUDGE_TASK, - "name", "Review listing directions - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listing directions")), - List.of( - Map.of( - "taskId", REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK, - "name", "Review listing directions case listed - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "AwaitingHearing", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Listed case")), - List.of( - Map.of( - "taskId", REVIEW_LIST_CASE_JUDGE_TASK, - "name", "Review list case - Judge", - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_HEARING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Strike out request")), - List.of( - Map.of( - "taskId", REVIEW_STRIKE_OUT_REQ_JUDGE_TASK, - "name", "Review strike out request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Strike out request")), - List.of( - Map.of( - "taskId", REVIEW_STRIKE_OUT_REQ_JUDGE_TASK, - "name", "Review strike out request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "CaseManagement", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Time extension request")), - List.of( - Map.of( - "taskId", REVIEW_TIME_EXT_REQ_JUDGE_TASK, - "name", "Review time extension request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "refer-to-judge", - "ReadyToList", - Map.of("Data", Map.of("cicCaseReferralTypeForWA", "Time extension request")), - List.of( - Map.of( - "taskId", REVIEW_TIME_EXT_REQ_JUDGE_TASK, - "name", "Review time extension request - Judge", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_JUDICIAL - ) - ) - ), - Arguments.of( - "caseworker-send-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseFirstOrderDueDate", "2026-04-02")), - List.of( - Map.of( - "taskId", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "name", "Follow up noncompliance of directions", - "delayUntil", DELAY_UNTIL_HOLIDAY_REQUEST, - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "citizen-cic-dss-update-case", - "*", - null, - List.of( - Map.of( - "taskId", PROCESS_FURTHER_EVIDENCE_TASK, - "name", "Process further evidence", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "caseworker-document-management", - "*", - null, - List.of( - Map.of( - "taskId", PROCESS_FURTHER_EVIDENCE_TASK, - "name", "Process further evidence", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "respondent-document-management", - "*", - null, - List.of( - Map.of( - "taskId", PROCESS_FURTHER_EVIDENCE_TASK, - "name", "Process further evidence", - "workingDaysAllowed", 7, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "caseworker-issue-case", - "CaseManagement", - null, - List.of( - Map.of( - "taskId", CREATE_DUE_DATE, - "name", "Create due date", - "workingDaysAllowed", 2, - "processCategories", PROCESS_CATEGORY_ISSUE_CASE, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - //test due date of create and send order - Arguments.of( - "create-and-send-order", - "CaseManagement", - Map.of("Data", Map.of("cicCaseFirstOrderDueDate", "2026-04-02")), - List.of( - Map.of( - "taskId", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "name", "Follow up noncompliance of directions", - "delayUntil", DELAY_UNTIL_HOLIDAY_REQUEST, - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-and-send-order", - "*", - Map.of("Data", Map.of("cicCaseAdminActionRequired", List.of("AdminActionRequired"))), - List.of( - Map.of( - "taskId", REVIEW_ORDER, - "name", "Review Order", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_DECISION, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ), - Arguments.of( - "create-and-send-order", - "CaseManagement", - Map.of("Data", - Map.of( - "cicCaseAdminActionRequired", List.of("AdminActionRequired"), - "cicCaseFirstOrderDueDate", "2026-04-02")), - List.of( - Map.of( - "taskId", FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - "name", "Follow up noncompliance of directions", - "delayUntil", DELAY_UNTIL_HOLIDAY_REQUEST, - "workingDaysAllowed", 1, - "processCategories", PROCESS_CATEGORY_PROCESSING, - "workType", ROUTINE_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ), - Map.of( - "taskId", REVIEW_ORDER, - "name", "Review Order", - "workingDaysAllowed", 5, - "processCategories", PROCESS_CATEGORY_DECISION, - "workType", DECISION_WORK_TYPE, - "roleCategory", ROLE_CATEGORY_ADMIN - ) - ) - ) - ); - } - - @Test - void if_this_test_fails_needs_updating_with_your_changes() { - //The purpose of this test is to prevent adding new rows without being tested - DmnDecisionTableImpl logic = (DmnDecisionTableImpl) decision.getDecisionLogic(); - assertThat(logic.getInputs().size(), is(5)); - assertThat(logic.getOutputs().size(), is(7)); - assertThat(logic.getRules().size(), is(65)); - } - - @ParameterizedTest(name = "event id: {0} post event state: {1} additional data: {2}") - @MethodSource("scenarioProvider") - void given_multiple_event_ids_should_evaluate_dmn(String eventId, - String postEventState, - Map map, - List> expectation) { - VariableMap inputVariables = new VariableMapImpl(); - inputVariables.putValue("eventId", eventId); - inputVariables.putValue("postEventState", postEventState); - inputVariables.putValue("additionalData", map); - DmnDecisionTableResult dmnDecisionTableResult = evaluateDmnTable(inputVariables); - - if (eventId.equals("caseworker-send-order") || eventId.equals("create-and-send-order")) { - assertNotNull(eventId); - } - assertThat(dmnDecisionTableResult.getResultList().size(), is(expectation.size())); - for (int i = 0; i < expectation.size(); i++) { - Map actualResult = dmnDecisionTableResult.getResultList().get(i); - Map expectedResult = expectation.get(i); - assertThat(actualResult.size(), is(expectedResult.size())); - - verifyResults(expectedResult, actualResult); - } - } - - private void verifyResults(Map expectedResult, Map actualResult) { - for (Map.Entry entry : expectedResult.entrySet()) { - String key = entry.getKey(); - Object expectedValueObject = entry.getValue(); - - if (!actualResult.containsKey(key)) { - fail("Actual DMN result is missing expected key: " + key); - } - - Object actualValueObj = actualResult.get(key); - - if ("delayUntil".equals(key)) { - verifyDelayUntilDate(actualValueObj, expectedValueObject); - } else { - assertThat(actualValueObj, is(expectedValueObject)); - } - } - } - - private void verifyDelayUntilDate(Object actualValueObj, Object expectedValueObject) { - if (actualValueObj instanceof Map actualValueMap) { - DelayUntilRequest delayUntilRequest = mapToDelayUntilRequest(actualValueMap); - if (expectedValueObject instanceof DelayUntilRequest expectedDelayUntilRequest - && !delayUntilRequest.equals(expectedDelayUntilRequest)) { - fail(String.format( - "DelayUntilRequest mismatch! \nExpected: %s \nActual: %s", - delayUntilRequest, expectedDelayUntilRequest)); - } - } else { - fail("Actual DMN result 'delayUntil' is not of expected type Map"); - } - } - - private static DelayUntilRequest mapToDelayUntilRequest(Map map) { - return DelayUntilRequest.builder() - .delayUntil(Objects.toString(map.get("delayUntil"), null)) - .delayUntilOrigin(Objects.toString(map.get("delayUntilOrigin"), null)) - .delayUntilTime(Objects.toString(map.get("delayUntilTime"), null)) - .delayUntilMustBeWorkingDay(Objects.toString(map.get("delayUntilMustBeWorkingDay"), null)) - .delayUntilSkipNonWorkingDays((Boolean) map.get("delayUntilSkipNonWorkingDays")) - .delayUntilIntervalDays(parseInteger(map.get("delayUntilIntervalDays"))) - .delayUntilNonWorkingCalendar(Objects.toString(map.get("delayUntilNonWorkingCalendar"), null)) - .delayUntilNonWorkingDaysOfWeek(Objects.toString(map.get("delayUntilNonWorkingDaysOfWeek"), null)) - .build(); - } - - private static Integer parseInteger(Object value) { - if (value == null) { - return null; - } - try { - return Integer.parseInt(value.toString()); - } catch (NumberFormatException e) { - return null; - } - } - -} diff --git a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaPermissionTest.java b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaPermissionTest.java index a65cd2b069..7ba1d739c6 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaPermissionTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/dmn/CamundaTaskWaPermissionTest.java @@ -23,78 +23,14 @@ import static org.hamcrest.CoreMatchers.is; import static org.hamcrest.MatcherAssert.assertThat; import static uk.gov.hmcts.sptribs.DmnDecisionTable.WA_TASK_PERMISSIONS_ST_CIC_CRIMINALINJURIESCOMPENSATION; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.COMPLETE_HEARING_OUTCOME_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.CREATE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_CASE_TO_RESPONDENT_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ISSUE_DUE_DATE; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CASE_WITHDRAWAL_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_CORRECTIONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_FURTHER_EVIDENCE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_LISTING_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_OTHER_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_POSTPONEMENT_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_RULE27_DECISION_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_SET_ASIDE_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_LISTED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STAY_DIR_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_STRIKE_OUT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_TIME_EXT_DIR_RETURNED_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.PROCESS_WRITTEN_REASONS_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REGISTER_NEW_CASE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_CORRECTIONS_REQ_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LISTING_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_ORDER; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_OTHER_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_POSTPONEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_REINSTATEMENT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_RULE27_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SET_ASIDE_REQ_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_ADMIN_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_CTSC_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_JUDICIARY_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_SPECIFIC_ACCESS_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STAY_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_STRIKE_OUT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_TIME_EXT_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_JUDGE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WITHDRAWAL_REQ_LO_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.REVIEW_WRITTEN_REASONS_REQ_TASK; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_ADMIN; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_CTSC; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_JUDICIAL; import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.ROLE_CATEGORY_LO; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.STITCH_COLLATE_HEARING_BUNDLE_TASK; -import static uk.gov.hmcts.sptribs.dmnutils.CamundaTaskConstants.VET_NEW_CASE_DOCUMENTS_TASK; class CamundaTaskWaPermissionTest extends DmnDecisionTableBaseUnitTest { @@ -107,296 +43,6 @@ public static void initialization() { static Stream scenarioProvider() { return Stream.of( - Arguments.of( - PROCESS_CASE_WITHDRAWAL_DIR_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_CASE_WITHDRAWAL_DIR_LISTED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_RULE27_DECISION_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_RULE27_DECISION_LISTED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_LISTING_DIR_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_LISTING_DIR_LISTED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_DIR_RELISTED_CASE_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_DIR_RELISTED_CASE_WITHIN_5DAYS_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_SET_ASIDE_DIR_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_CORRECTIONS_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_DIR_RETURNED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_POSTPONEMENT_DIR_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_FURTHER_EVIDENCE_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_TIME_EXT_DIR_RETURNED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_REINSTATEMENT_DECISION_NOTICE_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_OTHER_DIR_RETURNED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_WRITTEN_REASONS_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_STRIKE_OUT_DIR_RETURNED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_STAY_DIR_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - PROCESS_STAY_DIR_LISTED_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - ISSUE_DECISION_NOTICE_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - COMPLETE_HEARING_OUTCOME_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - ISSUE_CASE_TO_RESPONDENT_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - VET_NEW_CASE_DOCUMENTS_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - REVIEW_NEW_CASE_PROVIDE_DIR_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_TIME_EXT_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_STRIKE_OUT_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_STAY_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_LISTING_DIR_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_CASE_LISTED_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_RULE27_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_RULE27_REQ_CASE_LISTED_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_LIST_CASE_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_LISTING_DIR_CASE_LISTED_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_OTHER_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_LIST_CASE_WITHIN_5DAYS_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_POSTPONEMENT_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_REINSTATEMENT_REQ_LO_TASK, - DUMMY_CASE_DATA, - defaultLegalOperationsPermissions() - ), - Arguments.of( - REVIEW_LIST_CASE_WITHIN_5DAYS_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_POSTPONEMENT_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_CORRECTIONS_REQ_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_WRITTEN_REASONS_REQ_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_REINSTATEMENT_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_SET_ASIDE_REQ_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_STAY_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_STAY_REQ_CASE_LISTED_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_NEW_CASE_PROVIDE_DIR_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_OTHER_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_WITHDRAWAL_REQ_CASE_LISTED_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_RULE27_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_RULE27_REQ_CASE_LISTED_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_LISTING_DIR_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_LISTING_DIR_CASE_LISTED_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_LIST_CASE_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_STRIKE_OUT_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), - Arguments.of( - REVIEW_TIME_EXT_REQ_JUDGE_TASK, - DUMMY_CASE_DATA, - defaultJudicialPermissions() - ), Arguments.of( REVIEW_SPECIFIC_ACCESS_REQ_JUDICIARY_TASK, DUMMY_CASE_DATA, @@ -416,36 +62,6 @@ static Stream scenarioProvider() { REVIEW_SPECIFIC_ACCESS_REQ_CTSC_TASK, DUMMY_CASE_DATA, defaultSpecificAccessRequestCtscPermissions() - ), - Arguments.of( - FOLLOW_UP_NONCOMPLIANCE_OF_DIR_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - REGISTER_NEW_CASE_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - STITCH_COLLATE_HEARING_BUNDLE_TASK, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - CREATE_DUE_DATE, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - ISSUE_DUE_DATE, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() - ), - Arguments.of( - REVIEW_ORDER, - DUMMY_CASE_DATA, - defaultAdminAndCtscTaskPermissions() ) ); } @@ -472,7 +88,7 @@ void if_this_test_fails_needs_updating_with_your_changes() { assertThat(logic.getOutputs().size(), is(7)); assertThatOutputContainInOrder(outputColumnIds, logic.getOutputs()); //Rules - assertThat(logic.getRules().size(), is(15)); + assertThat(logic.getRules().size(), is(6)); } @ParameterizedTest(name = "task type: {0} case data: {1}") @@ -499,34 +115,6 @@ private void assertThatOutputContainInOrder(List outputColumnIds, List assertThat(output.get(i).getOutputName(), is(outputColumnIds.get(i)))); } - private static List> defaultAdminAndCtscTaskPermissions() { - return List.of( - taskSupervisorPermissions(), - regionalCentreAdminPermissions(), - regionalCentreTeamLeaderPermissions(), - hearingCentreAdminPermissions(), - hearingCentreTeamLeaderPermissions(), - ctscPermissions(), - ctscTeamLeaderPermissions() - ); - } - - private static List> defaultLegalOperationsPermissions() { - return List.of( - taskSupervisorPermissions(), - seniorTribunalCaseworkerPermissions(), - tribunalCaseworkerPermissions() - ); - } - - private static List> defaultJudicialPermissions() { - return List.of( - taskSupervisorPermissions(), - seniorJudgePermissions(), - judgePermissions() - ); - } - private static List> defaultSpecificAccessRequestJudicialPermissions() { return List.of( taskSupervisorPermissions(), @@ -564,46 +152,6 @@ private static Map taskSupervisorPermissions() { ); } - private static Map regionalCentreAdminPermissions() { - return Map.of( - "name", "regional-centre-admin", - "value", "Read,Own,Claim,Unclaim,Manage,Complete", - "roleCategory", ROLE_CATEGORY_ADMIN, - "assignmentPriority", 1, - "autoAssignable", false - ); - } - - private static Map regionalCentreTeamLeaderPermissions() { - return Map.of( - "name", "regional-centre-team-leader", - "value", "Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete", - "roleCategory", ROLE_CATEGORY_ADMIN, - "assignmentPriority", 2, - "autoAssignable", false - ); - } - - private static Map hearingCentreAdminPermissions() { - return Map.of( - "name", "hearing-centre-admin", - "value", "Read,Own,Claim,Unclaim,Manage,Complete", - "roleCategory", ROLE_CATEGORY_ADMIN, - "assignmentPriority", 1, - "autoAssignable", false - ); - } - - private static Map hearingCentreTeamLeaderPermissions() { - return Map.of( - "name", "hearing-centre-team-leader", - "value", "Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete", - "roleCategory", ROLE_CATEGORY_ADMIN, - "assignmentPriority", 2, - "autoAssignable", false - ); - } - private static Map seniorTribunalCaseworkerPermissions() { return Map.of( "name", "senior-tribunal-caseworker", @@ -614,38 +162,6 @@ private static Map seniorTribunalCaseworkerPermissions() { ); } - private static Map tribunalCaseworkerPermissions() { - return Map.of( - "name", "tribunal-caseworker", - "value", "Read,Own,Claim,Assign,Unassign,Complete,Cancel", - "roleCategory", ROLE_CATEGORY_LO, - "assignmentPriority", 2, - "autoAssignable", false - ); - } - - private static Map seniorJudgePermissions() { - return Map.of( - "name", "senior-judge", - "value", "Read,Execute,Claim,Manage,Assign,Unassign,Complete,Cancel", - "roleCategory", ROLE_CATEGORY_JUDICIAL, - "authorisations", "328", - "assignmentPriority", 1, - "autoAssignable", false - ); - } - - private static Map judgePermissions() { - return Map.of( - "name", "judge", - "value", "Read,Own,Claim,Assign,Unassign,Complete,Cancel", - "roleCategory", ROLE_CATEGORY_JUDICIAL, - "authorisations", "328", - "assignmentPriority", 2, - "autoAssignable", false - ); - } - private static Map leadershipJudgePermissions() { return Map.of( "name", "leadership-judge", @@ -683,25 +199,4 @@ private static Map ctscTeamLeaderSpecificAccessPermissions() { "autoAssignable", false ); } - - private static Map ctscPermissions() { - return Map.of( - "name", "ctsc", - "value", "Read,Own,Claim,Unclaim,Manage,Complete", - "roleCategory", ROLE_CATEGORY_CTSC, - "assignmentPriority", 1, - "autoAssignable", false - ); - } - - private static Map ctscTeamLeaderPermissions() { - return Map.of( - "name", "ctsc-team-leader", - "value", "Read,Own,Claim,Unclaim,Manage,UnclaimAssign,Assign,Unassign,Cancel,Complete", - "roleCategory", ROLE_CATEGORY_CTSC, - "assignmentPriority", 2, - "autoAssignable", false - ); - } - } diff --git a/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcomeTest.java b/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcomeTest.java index 546d11a08e..e1a9ec5b18 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcomeTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerCompleteHearingOutcomeTest.java @@ -3,6 +3,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.ccd.sdk.ConfigBuilderImpl; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -12,13 +13,19 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.caseworker.model.YesNo.YES; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.systemupdate.event.SystemTriggerCompleteHearingOutcome.SYSTEM_TRIGGER_COMPLETE_HEARING_OUTCOME; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.completeHearingOutcome; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; +import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @ExtendWith(MockitoExtension.class) class SystemTriggerCompleteHearingOutcomeTest { @@ -26,6 +33,9 @@ class SystemTriggerCompleteHearingOutcomeTest { @InjectMocks private SystemTriggerCompleteHearingOutcome systemTriggerCompleteHearingOutcome; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { final ConfigBuilderImpl configBuilder = createCaseDataConfigBuilder(); @@ -36,10 +46,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(SYSTEM_TRIGGER_COMPLETE_HEARING_OUTCOME); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -56,10 +62,12 @@ void shouldSetStitchHearingBundleTaskToYesInAboutToSubmit() { final CaseData caseData = new CaseData(); final CaseDetails caseDetails = new CaseDetails<>(); caseDetails.setData(caseData); + caseDetails.setId(TEST_CASE_ID); final AboutToStartOrSubmitResponse response = systemTriggerCompleteHearingOutcome .aboutToSubmit(caseDetails, caseDetails); assertThat(response.getData().getCompleteHearingOutcomeTask()).isEqualTo(YES); + verify(taskManagementService).enqueueInitiationTasks(List.of(completeHearingOutcome), caseData, TEST_CASE_ID); } } diff --git a/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundleTest.java b/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundleTest.java index d3c3f57bc4..f27abaf70e 100644 --- a/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundleTest.java +++ b/src/test/java/uk/gov/hmcts/sptribs/systemupdate/event/SystemTriggerStitchCollateHearingBundleTest.java @@ -3,6 +3,7 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import org.mockito.InjectMocks; +import org.mockito.Mock; import org.mockito.junit.jupiter.MockitoExtension; import uk.gov.hmcts.ccd.sdk.ConfigBuilderImpl; import uk.gov.hmcts.ccd.sdk.api.CaseDetails; @@ -12,13 +13,19 @@ import uk.gov.hmcts.sptribs.ciccase.model.State; import uk.gov.hmcts.sptribs.ciccase.model.UserRole; import uk.gov.hmcts.sptribs.ciccase.model.access.Permissions; +import uk.gov.hmcts.sptribs.taskmanagement.TaskManagementService; + +import java.util.List; import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.verify; import static uk.gov.hmcts.sptribs.caseworker.model.YesNo.YES; import static uk.gov.hmcts.sptribs.ciccase.model.UserRole.ST_CIC_WA_CONFIG_USER; import static uk.gov.hmcts.sptribs.systemupdate.event.SystemTriggerStitchCollateHearingBundle.SYSTEM_TRIGGER_STITCH_COLLATE_HEARING_BUNDLE; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.stitchCollateHearingBundle; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.createCaseDataConfigBuilder; import static uk.gov.hmcts.sptribs.testutil.ConfigTestUtil.getEventsFrom; +import static uk.gov.hmcts.sptribs.testutil.TestConstants.TEST_CASE_ID; @ExtendWith(MockitoExtension.class) class SystemTriggerStitchCollateHearingBundleTest { @@ -26,6 +33,9 @@ class SystemTriggerStitchCollateHearingBundleTest { @InjectMocks private SystemTriggerStitchCollateHearingBundle systemTriggerStitchCollateHearingBundle; + @Mock + private TaskManagementService taskManagementService; + @Test void shouldAddPublishToCamundaWhenWAIsEnabled() { final ConfigBuilderImpl configBuilder = createCaseDataConfigBuilder(); @@ -36,10 +46,6 @@ void shouldAddPublishToCamundaWhenWAIsEnabled() { .extracting(Event::getId) .contains(SYSTEM_TRIGGER_STITCH_COLLATE_HEARING_BUNDLE); - assertThat(getEventsFrom(configBuilder).values()) - .extracting(Event::isPublishToCamunda) - .contains(true); - assertThat(getEventsFrom(configBuilder).values()) .extracting(Event::getGrants) .extracting(map -> map.containsKey(ST_CIC_WA_CONFIG_USER)) @@ -56,10 +62,12 @@ void shouldSetStitchHearingBundleTaskToYesInAboutToSubmit() { final CaseData caseData = new CaseData(); final CaseDetails caseDetails = new CaseDetails<>(); caseDetails.setData(caseData); + caseDetails.setId(TEST_CASE_ID); final AboutToStartOrSubmitResponse response = systemTriggerStitchCollateHearingBundle .aboutToSubmit(caseDetails, caseDetails); assertThat(response.getData().getStitchHearingBundleTask()).isEqualTo(YES); + verify(taskManagementService).enqueueInitiationTasks(List.of(stitchCollateHearingBundle), caseData, TEST_CASE_ID); } } diff --git a/src/test/java/uk/gov/hmcts/sptribs/taskmanagement/TaskInitiationResolverTest.java b/src/test/java/uk/gov/hmcts/sptribs/taskmanagement/TaskInitiationResolverTest.java new file mode 100644 index 0000000000..36dae2c833 --- /dev/null +++ b/src/test/java/uk/gov/hmcts/sptribs/taskmanagement/TaskInitiationResolverTest.java @@ -0,0 +1,206 @@ +package uk.gov.hmcts.sptribs.taskmanagement; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import uk.gov.hmcts.sptribs.ciccase.model.AdminAction; +import uk.gov.hmcts.sptribs.ciccase.model.State; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.time.LocalDate; +import java.util.List; +import java.util.Set; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.assertThat; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.CORRECTIONS; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.LISTED_CASE; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.LISTED_CASE_WITHIN_5_DAYS; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.LISTING_DIRECTIONS; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.NEW_CASE; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.OTHER; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.POSTPONEMENT_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.REINSTATEMENT_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.RULE_27_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.SET_ASIDE_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.STAY_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.STRIKE_OUT_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.TIME_EXTENSION_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.WITHDRAWAL_REQUEST; +import static uk.gov.hmcts.sptribs.caseworker.model.ReferralReason.WRITTEN_REASONS_REQUEST; +import static uk.gov.hmcts.sptribs.ciccase.model.State.AwaitingHearing; +import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseClosed; +import static uk.gov.hmcts.sptribs.ciccase.model.State.CaseManagement; +import static uk.gov.hmcts.sptribs.ciccase.model.State.ReadyToList; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.followUpNoncomplianceOfDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.issueDueDate; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCaseWithdrawalDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCaseWithdrawalDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processCorrections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReListedCase; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReListedCaseWithin5Days; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processListingDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processListingDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processOtherDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processPostponementDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processReinstatementDecisionNotice; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processRule27DecisionListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processSetAsideDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStayDirections; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStayDirectionsListed; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processStrikeOutDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processTimeExtensionDirectionsReturned; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.processWrittenReasons; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewCorrectionsRequest; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseWithin5DaysJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListCaseWithin5DaysLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewListingDirectionsLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewNewCaseAndProvideDirectionsJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewNewCaseAndProvideDirectionsLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOrder; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOtherRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewOtherRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewPostponementRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewPostponementRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewReinstatementRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewReinstatementRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewRule27RequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewSetAsideRequest; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStayRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStrikeOutRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewStrikeOutRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewTimeExtensionRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewTimeExtensionRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestCaseListedJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestCaseListedLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestJudge; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWithdrawalRequestLO; +import static uk.gov.hmcts.sptribs.taskmanagement.model.TaskType.reviewWrittenReasonsRequest; + +class TaskInitiationResolverTest { + + @ParameterizedTest + @MethodSource("createDraftOrderInitiationCases") + void shouldResolveCreateDraftOrderInitiationTasks(State state, String referralType, List expected) { + assertThat(TaskInitiationResolver.createDraftOrderInitiationTasks(state, referralType)) + .containsExactlyElementsOf(expected); + } + + @ParameterizedTest + @MethodSource("referToJudgeCases") + void shouldResolveReferToJudgeInitiationTasks(State state, String referralType, List expected) { + assertThat(TaskInitiationResolver.referToJudgeInitiationTasks(state, referralType)) + .containsExactlyElementsOf(expected); + } + + @ParameterizedTest + @MethodSource("referToLegalOfficerCases") + void shouldResolveReferToLegalOfficerInitiationTasks(State state, String referralType, List expected) { + assertThat(TaskInitiationResolver.referToLegalOfficerInitiationTasks(state, referralType)) + .containsExactlyElementsOf(expected); + } + + @Test + void shouldResolveCreateAndSendOrderInitiationTasks() { + LocalDate dueDate = LocalDate.of(2026, 2, 1); + + assertThat(TaskInitiationResolver.createAndSendOrderInitiationTasks( + CaseManagement, dueDate, Set.of(AdminAction.ADMIN_ACTION_REQUIRED))) + .containsExactly(followUpNoncomplianceOfDirections, reviewOrder); + + assertThat(TaskInitiationResolver.createAndSendOrderInitiationTasks( + ReadyToList, dueDate, Set.of(AdminAction.ADMIN_ACTION_REQUIRED))) + .containsExactly(reviewOrder); + + assertThat(TaskInitiationResolver.createAndSendOrderInitiationTasks(CaseManagement, dueDate, null)) + .containsExactly(followUpNoncomplianceOfDirections); + + assertThat(TaskInitiationResolver.createAndSendOrderInitiationTasks(CaseManagement, null, null)).isEmpty(); + } + + private static Stream createDraftOrderInitiationCases() { + return Stream.of( + Arguments.of(CaseManagement, null, List.of(issueDueDate)), + Arguments.of(CaseManagement, " ", List.of(issueDueDate)), + Arguments.of(AwaitingHearing, WITHDRAWAL_REQUEST.getLabel(), List.of(processCaseWithdrawalDirectionsListed)), + Arguments.of(ReadyToList, WITHDRAWAL_REQUEST.getLabel(), List.of(processCaseWithdrawalDirections)), + Arguments.of(AwaitingHearing, RULE_27_REQUEST.getLabel(), List.of(processRule27DecisionListed)), + Arguments.of(CaseManagement, LISTING_DIRECTIONS.getLabel(), List.of(processListingDirections)), + Arguments.of(ReadyToList, LISTING_DIRECTIONS.getLabel(), List.of(processListingDirectionsListed)), + Arguments.of(AwaitingHearing, LISTED_CASE.getLabel(), List.of(processDirectionsReListedCase)), + Arguments.of(AwaitingHearing, LISTED_CASE_WITHIN_5_DAYS.getLabel(), List.of(processDirectionsReListedCaseWithin5Days)), + Arguments.of(CaseClosed, SET_ASIDE_REQUEST.getLabel(), List.of(processSetAsideDirections)), + Arguments.of(CaseClosed, CORRECTIONS.getLabel(), List.of(processCorrections)), + Arguments.of(CaseManagement, NEW_CASE.getLabel(), List.of(processDirectionsReturned)), + Arguments.of(AwaitingHearing, POSTPONEMENT_REQUEST.getLabel(), List.of(processPostponementDirections)), + Arguments.of(ReadyToList, TIME_EXTENSION_REQUEST.getLabel(), List.of(processTimeExtensionDirectionsReturned)), + Arguments.of(CaseClosed, REINSTATEMENT_REQUEST.getLabel(), List.of(processReinstatementDecisionNotice)), + Arguments.of(CaseManagement, OTHER.getLabel(), List.of(processOtherDirectionsReturned)), + Arguments.of(CaseClosed, WRITTEN_REASONS_REQUEST.getLabel(), List.of(processWrittenReasons)), + Arguments.of(CaseManagement, STRIKE_OUT_REQUEST.getLabel(), List.of(processStrikeOutDirectionsReturned)), + Arguments.of(AwaitingHearing, STAY_REQUEST.getLabel(), List.of(processStayDirectionsListed)), + Arguments.of(CaseManagement, STAY_REQUEST.getLabel(), List.of(processStayDirections)), + Arguments.of(CaseManagement, "Unmapped", List.of()) + ); + } + + private static Stream referToJudgeCases() { + return Stream.of( + Arguments.of(AwaitingHearing, LISTED_CASE_WITHIN_5_DAYS.getLabel(), List.of(reviewListCaseWithin5DaysJudge)), + Arguments.of(AwaitingHearing, POSTPONEMENT_REQUEST.getLabel(), List.of(reviewPostponementRequestJudge)), + Arguments.of(CaseClosed, CORRECTIONS.getLabel(), List.of(reviewCorrectionsRequest)), + Arguments.of(CaseClosed, WRITTEN_REASONS_REQUEST.getLabel(), List.of(reviewWrittenReasonsRequest)), + Arguments.of(CaseClosed, REINSTATEMENT_REQUEST.getLabel(), List.of(reviewReinstatementRequestJudge)), + Arguments.of(CaseClosed, SET_ASIDE_REQUEST.getLabel(), List.of(reviewSetAsideRequest)), + Arguments.of(AwaitingHearing, STAY_REQUEST.getLabel(), List.of(reviewStayRequestCaseListedJudge)), + Arguments.of(CaseManagement, STAY_REQUEST.getLabel(), List.of(reviewStayRequestJudge)), + Arguments.of(ReadyToList, NEW_CASE.getLabel(), List.of(reviewNewCaseAndProvideDirectionsJudge)), + Arguments.of(CaseManagement, OTHER.getLabel(), List.of(reviewOtherRequestJudge)), + Arguments.of(AwaitingHearing, WITHDRAWAL_REQUEST.getLabel(), List.of(reviewWithdrawalRequestCaseListedJudge)), + Arguments.of(CaseManagement, WITHDRAWAL_REQUEST.getLabel(), List.of(reviewWithdrawalRequestJudge)), + Arguments.of(AwaitingHearing, RULE_27_REQUEST.getLabel(), List.of(reviewRule27RequestCaseListedJudge)), + Arguments.of(ReadyToList, RULE_27_REQUEST.getLabel(), List.of(reviewRule27RequestJudge)), + Arguments.of(CaseManagement, LISTING_DIRECTIONS.getLabel(), List.of(reviewListingDirectionsJudge)), + Arguments.of(ReadyToList, LISTING_DIRECTIONS.getLabel(), List.of(reviewListingDirectionsCaseListedJudge)), + Arguments.of(AwaitingHearing, LISTED_CASE.getLabel(), List.of(reviewListCaseJudge)), + Arguments.of(CaseManagement, STRIKE_OUT_REQUEST.getLabel(), List.of(reviewStrikeOutRequestJudge)), + Arguments.of(ReadyToList, TIME_EXTENSION_REQUEST.getLabel(), List.of(reviewTimeExtensionRequestJudge)), + Arguments.of(CaseManagement, "Unmapped", List.of()) + ); + } + + private static Stream referToLegalOfficerCases() { + return Stream.of( + Arguments.of(CaseManagement, NEW_CASE.getLabel(), List.of(reviewNewCaseAndProvideDirectionsLO)), + Arguments.of(ReadyToList, TIME_EXTENSION_REQUEST.getLabel(), List.of(reviewTimeExtensionRequestLO)), + Arguments.of(CaseManagement, STRIKE_OUT_REQUEST.getLabel(), List.of(reviewStrikeOutRequestLO)), + Arguments.of(AwaitingHearing, STAY_REQUEST.getLabel(), List.of(reviewStayRequestCaseListedLO)), + Arguments.of(CaseManagement, STAY_REQUEST.getLabel(), List.of(reviewStayRequestLO)), + Arguments.of(CaseManagement, LISTING_DIRECTIONS.getLabel(), List.of(reviewListingDirectionsLO)), + Arguments.of(ReadyToList, LISTING_DIRECTIONS.getLabel(), List.of(reviewListingDirectionsCaseListedLO)), + Arguments.of(AwaitingHearing, WITHDRAWAL_REQUEST.getLabel(), List.of(reviewWithdrawalRequestCaseListedLO)), + Arguments.of(ReadyToList, WITHDRAWAL_REQUEST.getLabel(), List.of(reviewWithdrawalRequestLO)), + Arguments.of(AwaitingHearing, RULE_27_REQUEST.getLabel(), List.of(reviewRule27RequestCaseListedLO)), + Arguments.of(CaseManagement, RULE_27_REQUEST.getLabel(), List.of(reviewRule27RequestLO)), + Arguments.of(AwaitingHearing, LISTED_CASE.getLabel(), List.of(reviewListCaseLO)), + Arguments.of(AwaitingHearing, LISTED_CASE_WITHIN_5_DAYS.getLabel(), List.of(reviewListCaseWithin5DaysLO)), + Arguments.of(AwaitingHearing, POSTPONEMENT_REQUEST.getLabel(), List.of(reviewPostponementRequestLO)), + Arguments.of(CaseClosed, REINSTATEMENT_REQUEST.getLabel(), List.of(reviewReinstatementRequestLO)), + Arguments.of(CaseManagement, OTHER.getLabel(), List.of(reviewOtherRequestLO)), + Arguments.of(CaseManagement, "Unmapped", List.of()) + ); + } +} diff --git a/src/test/java/uk/gov/hmcts/sptribs/taskmanagement/TaskManagementServiceTest.java b/src/test/java/uk/gov/hmcts/sptribs/taskmanagement/TaskManagementServiceTest.java new file mode 100644 index 0000000000..4554486cbc --- /dev/null +++ b/src/test/java/uk/gov/hmcts/sptribs/taskmanagement/TaskManagementServiceTest.java @@ -0,0 +1,201 @@ +package uk.gov.hmcts.sptribs.taskmanagement; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import uk.gov.hmcts.ccd.sdk.taskmanagement.TaskOutboxService; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.TaskPayload; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.TaskPermission; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.outbox.TerminateTaskOutboxPayload; +import uk.gov.hmcts.ccd.sdk.taskmanagement.model.request.TaskCreateRequest; +import uk.gov.hmcts.ccd.sdk.type.DynamicList; +import uk.gov.hmcts.ccd.sdk.type.DynamicListElement; +import uk.gov.hmcts.sptribs.caseworker.model.CaseManagementLocation; +import uk.gov.hmcts.sptribs.caseworker.model.SecurityClass; +import uk.gov.hmcts.sptribs.ciccase.model.CaseData; +import uk.gov.hmcts.sptribs.taskmanagement.model.TaskType; + +import java.time.LocalDate; +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; + +@ExtendWith(MockitoExtension.class) +class TaskManagementServiceTest { + + private static final long CASE_ID = 1234567890L; + + @Mock + private TaskOutboxService taskOutboxService; + + @InjectMocks + private TaskManagementService taskManagementService; + + @Test + void shouldIgnoreNullOrEmptyInitiationTasks() { + CaseData caseData = CaseData.builder().build(); + + taskManagementService.enqueueInitiationTasks(null, caseData, CASE_ID); + taskManagementService.enqueueInitiationTasks(List.of(), caseData, CASE_ID); + + verifyNoInteractions(taskOutboxService); + } + + @Test + void shouldEnqueueDistinctInitiationTasks() { + CaseData caseData = CaseData.builder() + .caseNameHmctsInternal("Case name") + .build(); + + taskManagementService.enqueueInitiationTasks( + List.of(TaskType.registerNewCase, TaskType.registerNewCase, TaskType.reviewSetAsideRequest), + caseData, + CASE_ID + ); + + ArgumentCaptor captor = ArgumentCaptor.forClass(TaskCreateRequest.class); + verify(taskOutboxService, times(2)).enqueueTaskCreateRequest(captor.capture()); + + List requests = captor.getAllValues(); + assertThat(requests).extracting(request -> request.task().getType()) + .containsExactly("registerNewCase", "reviewSetAsideRequest"); + } + + @Test + void shouldMapTaskPayloadWithDefaultsWhenCaseDataFieldsMissing() { + CaseData caseData = CaseData.builder() + .caseNameHmctsInternal("Case name") + .build(); + + taskManagementService.enqueueInitiationTasks(List.of(TaskType.registerNewCase), caseData, CASE_ID); + + ArgumentCaptor captor = ArgumentCaptor.forClass(TaskCreateRequest.class); + verify(taskOutboxService).enqueueTaskCreateRequest(captor.capture()); + TaskPayload payload = captor.getValue().task(); + + assertThat(payload.getCaseId()).isEqualTo(String.valueOf(CASE_ID)); + assertThat(payload.getCaseTypeId()).isEqualTo("CriminalInjuriesCompensation"); + assertThat(payload.getCaseName()).isEqualTo("Case name"); + assertThat(payload.getCaseCategory()).isEqualTo("Criminal Injuries Compensation"); + assertThat(payload.getRegion()).isEqualTo("1"); + assertThat(payload.getLocation()).isEqualTo("336559"); + assertThat(payload.getSecurityClassification()).isEqualTo("PUBLIC"); + assertThat(payload.getTaskSystem()).isEqualTo("SELF"); + assertThat(payload.getExecutionType()).isEqualTo("Case Management Task"); + assertThat(payload.getPermissions()) + .extracting(TaskPermission::getRoleName) + .containsExactly( + "regional-centre-admin", + "regional-centre-team-leader", + "hearing-centre-admin", + "hearing-centre-team-leader", + "ctsc", + "ctsc-team-leader", + "task-supervisor"); + + OffsetDateTime nowUtc = OffsetDateTime.now(ZoneOffset.UTC); + assertThat(payload.getPriorityDate()).isBetween(nowUtc.minusMinutes(1), nowUtc.plusMinutes(1)); + assertThat(payload.getDueDateTime()) + .isBetween(nowUtc.plusDays(4), nowUtc.plusDays(6)); + } + + @Test + void shouldMapTaskPayloadWithCaseDataOverridesAndLegalOperationsPermissions() { + LocalDate dueDate = LocalDate.of(2026, 2, 10); + CaseData caseData = CaseData.builder() + .caseNameHmctsInternal("Case name") + .dueDate(dueDate) + .securityClass(SecurityClass.PRIVATE) + .caseManagementCategory(DynamicList.builder() + .value(DynamicListElement.builder().code(UUID.randomUUID()).label("Custom Category").build()) + .build()) + .caseManagementLocation(CaseManagementLocation.builder() + .region("11") + .baseLocation("366559") + .build()) + .build(); + + taskManagementService.enqueueInitiationTasks( + List.of(TaskType.reviewNewCaseAndProvideDirectionsLO), + caseData, + CASE_ID + ); + + ArgumentCaptor captor = ArgumentCaptor.forClass(TaskCreateRequest.class); + verify(taskOutboxService).enqueueTaskCreateRequest(captor.capture()); + TaskPayload payload = captor.getValue().task(); + + assertThat(payload.getSecurityClassification()).isEqualTo("PRIVATE"); + assertThat(payload.getCaseCategory()).isEqualTo("Custom Category"); + assertThat(payload.getRegion()).isEqualTo("11"); + assertThat(payload.getLocation()).isEqualTo("366559"); + assertThat(payload.getPriorityDate()).isEqualTo(dueDate.atStartOfDay().atOffset(ZoneOffset.UTC)); + assertThat(payload.getPermissions()).extracting(TaskPermission::getRoleName) + .containsExactly("senior-tribunal-caseworker", "tribunal-caseworker", "task-supervisor"); + } + + @Test + void shouldMapJudicialPermissionsWhenJudicialTaskInitiated() { + taskManagementService.enqueueInitiationTasks( + List.of(TaskType.reviewNewCaseAndProvideDirectionsJudge), + CaseData.builder().build(), + CASE_ID + ); + + ArgumentCaptor captor = ArgumentCaptor.forClass(TaskCreateRequest.class); + verify(taskOutboxService).enqueueTaskCreateRequest(captor.capture()); + TaskPayload payload = captor.getValue().task(); + + assertThat(payload.getPermissions()).extracting(TaskPermission::getRoleName) + .containsExactly("senior-judge", "judge", "task-supervisor"); + } + + @Test + void shouldEnqueueCompletionAndCancellationRequests() { + List taskTypes = List.of(TaskType.reviewOrder, TaskType.processFurtherEvidence); + + taskManagementService.enqueueCompletionTasks(taskTypes, CASE_ID); + taskManagementService.enqueueCancellationTasks(taskTypes, CASE_ID); + + ArgumentCaptor completeCaptor = ArgumentCaptor.forClass(TerminateTaskOutboxPayload.class); + verify(taskOutboxService).enqueueTaskCompleteRequest(completeCaptor.capture()); + assertThat(completeCaptor.getValue()) + .isEqualTo(new TerminateTaskOutboxPayload( + String.valueOf(CASE_ID), + "CriminalInjuriesCompensation", + List.of("reviewOrder", "processFurtherEvidence") + )); + + ArgumentCaptor cancelCaptor = ArgumentCaptor.forClass(TerminateTaskOutboxPayload.class); + verify(taskOutboxService).enqueueTaskCancelRequest(cancelCaptor.capture()); + assertThat(cancelCaptor.getValue()) + .isEqualTo(new TerminateTaskOutboxPayload( + String.valueOf(CASE_ID), + "CriminalInjuriesCompensation", + List.of("reviewOrder", "processFurtherEvidence") + )); + } + + @Test + void shouldIgnoreNullOrEmptyCompletionAndCancellationTasks() { + taskManagementService.enqueueCompletionTasks(null, CASE_ID); + taskManagementService.enqueueCompletionTasks(List.of(), CASE_ID); + taskManagementService.enqueueCancellationTasks(null, CASE_ID); + taskManagementService.enqueueCancellationTasks(List.of(), CASE_ID); + + verify(taskOutboxService, never()).enqueueTaskCompleteRequest(any()); + verify(taskOutboxService, never()).enqueueTaskCancelRequest(any()); + verify(taskOutboxService, never()).enqueueTaskCreateRequest(any()); + } +}