diff --git a/.github/workflows/backend-tests.yml b/.github/workflows/backend-tests.yml new file mode 100644 index 000000000..634b8d298 --- /dev/null +++ b/.github/workflows/backend-tests.yml @@ -0,0 +1,31 @@ +name: Backend tests + +on: + pull_request: + push: + branches: [master] + workflow_dispatch: + +permissions: + contents: read + +jobs: + test: + runs-on: ubuntu-latest + container: maven:3.9-eclipse-temurin-21 + services: + postgres: + image: postgres:14 + env: + POSTGRES_DB: platform_test + POSTGRES_USER: postgres + POSTGRES_PASSWORD: postgres + options: >- + --health-cmd pg_isready + --health-interval 5s + --health-timeout 5s + --health-retries 10 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - name: Unit, HTTP contract, migration, and persistence tests + run: mvn -B -ntp -Ppostgres-integration -Dit.database.url=jdbc:postgresql://postgres:5432/platform_test clean verify diff --git a/AGENTS.md b/AGENTS.md index b31633bf5..bc9f8d9ee 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -8,9 +8,9 @@ This repository contains the Spring Boot backend for the Medical Informatics Pla - `src/main/java/hbp/mip/configurations`: security, OAuth2/JWT, persistence, OpenAPI, and redirect/filter configuration. - `src/main/java/hbp/mip/algorithm`: algorithm metadata API/service and Exaflow specification passthrough. - `src/main/java/hbp/mip/datamodel`: data model API/service backed by Exaflow metadata endpoints. -- `src/main/java/hbp/mip/experiment`: experiment API, service, repository, JPA entity, specifications, and DTOs. +- `src/main/java/hbp/mip/analysis`: analysis API, service, repository, JPA entity, specifications, and DTOs. - `src/main/java/hbp/mip/user`: active user API/service, user repository, JPA entity, and DTO. -- `src/main/java/hbp/mip/folder`: experiment folder/set API, service, repository, JPA entities, and DTOs. +- `src/main/java/hbp/mip/study`: Study/Analysis Group API, service, repository, JPA entities, and DTOs. - `src/main/java/hbp/mip/utils`: shared logging, JSON/HTTP helpers, claim validation, and exception handling. - `src/main/resources`: local runtime config, Log4j2 config, and Flyway migrations under `db/migration`. - `.github/workflows`: release image publishing and EBRAINS mirror automation. @@ -55,7 +55,7 @@ The Maven build produces `target/platform-backend.jar`. mvn test ``` -There is currently no committed `src/test/java` tree. Treat `mvn test` as the baseline smoke check until focused tests are added. +`mvn test` runs JUnit/Mockito and MockMvc tests. Run `mvn -Ppostgres-integration verify` against a disposable PostgreSQL database for migration and persistence coverage; connection properties are documented in `docs/context/testing.md`. ## Lint / Format / Typecheck ```bash @@ -74,7 +74,7 @@ mvn clean package ## Architecture Rules - Put HTTP endpoints in `*API` classes under the owning feature package. - Put business logic in `*Service` classes; controllers should delegate rather than implement workflows directly. -- Put persistence in Spring Data repositories and JPA `*DAO` entities. Current JPA packages are `hbp.mip.experiment`, `hbp.mip.user`, and `hbp.mip.folder` (list them in `PersistenceConfiguration` when adding another). +- Put persistence in Spring Data repositories and JPA `*DAO` entities. Current JPA packages are `hbp.mip.analysis`, `hbp.mip.user`, and `hbp.mip.study` (list them in `PersistenceConfiguration` when adding another). - Put API/request/response shapes in `*DTO` records or DTO classes close to the feature package. - Put cross-cutting helpers in `hbp.mip.utils` only when they are genuinely shared. - Put security, persistence, OpenAPI, and web filter wiring in `hbp.mip.configurations`. @@ -113,10 +113,10 @@ mvn clean package ## Security and Privacy Rules - Never commit secrets, tokens, keys, cookies, credentials, or private environment values. - Never print secrets in logs or final reports. -- Treat auth, authorization claims, CSRF, token exposure, migrations, data deletion, and experiment execution as human-review areas. +- Treat auth, authorization claims, CSRF, token exposure, migrations, data deletion, and analysis execution as human-review areas. - Preserve OAuth2 login and bearer-token behavior unless the task explicitly changes auth. -- Preserve dataset and experiment access checks in `ClaimUtils` and `ExperimentService`. -- Review logs carefully when touching experiment execution, active user token handling, or external service calls. +- Preserve dataset and analysis access checks in `ClaimUtils` and `AnalysisService`. +- Review logs carefully when touching analysis execution, active user token handling, or external service calls. ## PR Expectations Every agent change should include: diff --git a/README.md b/README.md index b6846eeda..76b8910e3 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,7 @@ To use this image, you need a running instance of PostgreSQL and to configure th #### AUTHENTICATION ### * AUTHENTICATION: true for production, false for development. +* `authentication.all_analyses_allowed_claim`: defaults to the existing external authority `research_experiment_all`. Preserve that authority and existing grants. #### DATABASE CONFIGURATION ### * PLATFORM_DB_URL: JDBC URL to connect to the platform database, default value is "jdbc:postgresql://127.0.0.1:5432/platform". @@ -27,8 +28,10 @@ To use this image, you need a running instance of PostgreSQL and to configure th #### EXTERNAL SERVICES ### * EXAFLOW_URL: URL to Exaflow server. Default is "http://localhost:5000" . -#### EXPERIMENTS ### -* EXPERIMENT_RUN_DRAFT_TTL: How long an unsaved studio run can still be saved without re-running it, as an ISO-8601 duration. Default is "PT24H". +#### ANALYSES ### +* ANALYSIS_RUN_DRAFT_TTL: How long an unsaved studio run can still be saved without re-running it, as an ISO-8601 duration. Default is "PT24H". + +The backend uses Analysis, Study, and Analysis Group terminology. See the [module index](docs/context/module-index.md) for API and persistence details. Run `mvn test`, `mvn -Ppostgres-integration verify` against a disposable PostgreSQL database, and `mvn clean package`; connection settings are in [the testing guide](docs/context/testing.md). #### KEYCLOAK ### * KEYCLOAK_AUTH_URL: Keycloak authentication URL. diff --git a/docs/context/architecture.md b/docs/context/architecture.md index 076e87a3d..2048177ed 100644 --- a/docs/context/architecture.md +++ b/docs/context/architecture.md @@ -6,9 +6,10 @@ This is a backend service for the Medical Informatics Platform. It is a Java 21 ## High-Level Structure The application entrypoint is `hbp.mip.MIPApplication`. APIs are grouped by feature package: -- `algorithm`: runs analyses through Exaflow (for the `experiment` package) and exposes Exaflow's inputdata, preprocessing and algorithm specifications (`/specifications/*`). +- `algorithm`: runs analyses through Exaflow (for the `analysis` package) and exposes Exaflow's inputdata, preprocessing and algorithm specifications (`/specifications/*`). - `datamodel`: exposes data models and dataset metadata from Exaflow, filtered by user claims when authentication is enabled. -- `experiment`: creates, lists, updates, deletes, and executes experiments; persists experiment records in PostgreSQL. +- `analysis`: manages platform Analysis records and the preview/run/save workflow. +- `study`: owns Studies, Analysis Groups, and ordered Analysis memberships. - `user`: resolves the active user from OAuth2/OIDC or JWT authentication and persists user profile/NDA state. - `configurations`: configures security, OAuth2/OIDC, JWT authority mapping, persistence, Flyway, OpenAPI, and SPA redirects. - `utils`: shared HTTP, JSON, logging, claim, resource, and exception utilities. @@ -28,7 +29,7 @@ flowchart TD - HTTP requests enter controllers named `*API`. - Controllers create a `hbp.mip.utils.Logger` with active user and endpoint context, then delegate to services. - Services enforce business rules, authorization checks, external calls, and persistence workflows. -- Repositories and JPA `*DAO` entities handle database access for users and experiments. +- Repositories and JPA `*DAO` entities handle database access for users and analyses. - DTOs are returned from controllers as API response shapes. - Exceptions are mapped by `ControllerExceptionHandler`. @@ -47,17 +48,17 @@ Persistence is configured in `PersistenceConfiguration`. - Data source properties come from `spring.datasource`. - Flyway runs at startup through a `flyway` bean. -- JPA scans `hbp.mip.experiment` and `hbp.mip.user`. -- Existing migration `V1__InitialSchema.sql` creates `user` and `experiment` tables. -- `V3__ExperimentRunDrafts.sql` creates `experiment_run`, which keeps unsaved studio run results until they are saved or expire. -- Hibernate is configured with `ddl-auto: validate`, so schema changes should be made through Flyway migrations. +- JPA scans `hbp.mip.analysis`, `hbp.mip.study`, and `hbp.mip.user`. +- Shipped migrations V1–V5 create the historical schema. V6 renames records to `analysis`, `analysis_run`, `study`, `analysis_group`, and `study_member`, with complete requests in `analysis_request`. +- Flyway owns schema changes. PostgreSQL integration tests explicitly validate JPA mappings against the migrated schema. ## API Layer The servlet context path is `/services`. Main endpoints include: -- `/algorithms` +- `/specifications/{inputdata,preprocessing,algorithms}` - `/data-models` -- `/experiments` (`/experiments/preview` computes without storing, `/experiments/runs` computes and keeps the result, `POST /experiments` saves a kept run) +- `/analyses` (`/analyses/preview` computes without storing, `/analyses/runs` computes and keeps the result, `POST /analyses` saves a kept run) +- `/studies` (owner-scoped Study, Analysis Group, and membership operations) - `/activeUser` OpenAPI is configured by `OpenApiConfig` and springdoc dependencies. @@ -72,21 +73,20 @@ OpenAPI is configured by `OpenApiConfig` and springdoc dependencies. - Raw authority mapping for claims and Keycloak roles, intentionally without adding a `ROLE_` prefix. - Anonymous development behavior when `authentication.enabled` is disabled. -Authorization-sensitive logic appears in `ClaimUtils`, `ExperimentService`, `DataModelService`, and active user handling. +Authorization-sensitive logic appears in `ClaimUtils`, `AnalysisService`, `DataModelService`, and active user handling. -## Background Work and External Services +## Execution and External Services - `SpecificationsService` fetches inputdata, preprocessing, and algorithm specifications from Exaflow per request. -- `ExperimentService` starts a background `Thread` for persisted experiment execution. +- `AnalysisService` executes preview/run synchronously through `AnalysisExecutionService`. Preview stores nothing; successful runs retain owner-only drafts. Save copies a retained result without execution. - Data model and algorithm metadata are fetched through `HTTPUtil` using configured Exaflow URLs. ## Config and Environment Model - All runtime config is in `src/main/resources/application.yml` with `${ENV:default}` placeholders. - Containers pass environment variables (see `mip/deployment`); no separate config template is rendered at startup. -- Important config areas include datasource, OAuth2/Keycloak, authentication flags, Exaflow URLs, frontend base URL, `MIP_VERSION`, `EXPERIMENT_RUN_DRAFT_TTL`, and logging. +- Important config areas include datasource, OAuth2/Keycloak, authentication flags, Exaflow URLs, frontend base URL, `MIP_VERSION`, `ANALYSIS_RUN_DRAFT_TTL`, and logging. - Do not introduce direct environment reads in business logic; route configuration through Spring properties. ## Known Gaps -- No committed `src/test/java` tree. - No Maven wrapper. - No Docker Compose or local database bootstrap file found. - No dedicated Java lint/formatter/static-analysis command found. diff --git a/docs/context/code-review-checklist.md b/docs/context/code-review-checklist.md index d3ad9c63e..833cc87e3 100644 --- a/docs/context/code-review-checklist.md +++ b/docs/context/code-review-checklist.md @@ -23,7 +23,7 @@ - [ ] No secrets are committed. - [ ] Sensitive values are not logged. - [ ] Auth/authz behavior is preserved or explicitly reviewed. -- [ ] Dataset and experiment access checks are preserved. +- [ ] Dataset and analysis access checks are preserved. - [ ] Token exposure and CSRF behavior are reviewed if touched. ## Maintainability diff --git a/docs/context/commands.md b/docs/context/commands.md index 3075ded52..689701771 100644 --- a/docs/context/commands.md +++ b/docs/context/commands.md @@ -37,7 +37,7 @@ target/platform-backend.jar mvn test ``` -There is no committed `src/test/java` tree. This command currently functions as the baseline Maven test phase/smoke check. +Runs JUnit/Mockito and HTTP contract tests. PostgreSQL integration tests require `mvn -Ppostgres-integration verify`; see [testing.md](testing.md) for connection properties. ## Lint ```bash @@ -70,9 +70,9 @@ Flyway migrations live in: src/main/resources/db/migration ``` -The application configures Flyway startup migration through `PersistenceConfiguration`. Hibernate uses `ddl-auto: validate`, so schema changes should be made through Flyway migrations. +The application configures Flyway startup migration through `PersistenceConfiguration`. Flyway owns schema changes; PostgreSQL integration tests explicitly validate Hibernate mappings. -Unknown / TODO: verify the preferred command for applying migrations against a local PostgreSQL instance outside app startup. +The `postgres-integration` Maven profile applies migrations to isolated test schemas, tests fresh and populated upgrades, and removes those schemas afterwards. ## Docker Build the container image: @@ -89,4 +89,4 @@ Detected workflows: - `.github/workflows/publish_images.yml`: on published release, builds and pushes Docker images to Docker Hub and EBRAINS Harbor. - `.github/workflows/ebrains.yml`: mirrors `master` and tags to EBRAINS GitLab on push. -No regular pull-request test workflow was found. +`backend-tests.yml` runs the package build, unit/HTTP tests, and PostgreSQL migration/persistence tests on pull requests and master pushes. diff --git a/docs/context/conventions.md b/docs/context/conventions.md index a37e9b898..591cb7224 100644 --- a/docs/context/conventions.md +++ b/docs/context/conventions.md @@ -9,7 +9,7 @@ - Repositories use the `*Repository` suffix. - JPA entities use the `*DAO` suffix. - API/request/response shapes use the `*DTO` suffix, often as Java records. -- Feature modules are grouped by package: `algorithm`, `datamodel`, `experiment`, and `user`. +- Feature modules are grouped by package: `algorithm`, `datamodel`, `analysis`, `study`, and `user`. ### Backend Layering - Controllers accept HTTP input, create user/action logs, and delegate to services. @@ -26,7 +26,7 @@ ### Logging - User-facing actions use `hbp.mip.utils.Logger`. - Logs include username, endpoint, and message. -- Existing code logs some request and experiment details; avoid expanding sensitive logging. +- Existing code logs some request and analysis details; avoid expanding sensitive logging. ### Configuration - Spring properties are defined in `src/main/resources/application.yml`. @@ -42,7 +42,7 @@ ### Persistence - Flyway owns migrations. - Hibernate validates schema with `ddl-auto: validate`. -- Current JPA repositories/entities are in `experiment` and `user`. +- Current JPA repositories/entities are in `analysis`, `study`, and `user`. ### Agent Tool and Token Budget - Agents should use focused repository inspection commands and avoid dumping broad context. @@ -51,8 +51,8 @@ - When large context is unavoidable, the agent should ask first, explain the expected size and reason, and summarize results instead of pasting raw output. ## Recommended Conventions to Verify -- Add a test dependency such as Spring Boot test support before creating substantive Java tests, if not already added by a future change. +- Use existing Spring Boot test support, JUnit, Mockito, and MockMvc. Use real PostgreSQL for schema and SQL-function checks. - Prefer constructor-bound configuration properties for new configuration-heavy code, but match local `@Value` style for small scoped changes. -- Prefer managed Spring executors for new background work instead of raw `Thread`, unless intentionally preserving existing behavior. +- Preserve synchronous preview/run/save. A terminology rename must not introduce background execution. - Prefer a Spring HTTP client abstraction for larger external integration changes; keep small fixes consistent with `HTTPUtil`. - Add a Java formatter/static-analysis command before enforcing style mechanically. diff --git a/docs/context/module-index.md b/docs/context/module-index.md index 9f1288e28..abf5af56e 100644 --- a/docs/context/module-index.md +++ b/docs/context/module-index.md @@ -30,15 +30,15 @@ Notes: Raw authority strings are intentional and should not be automatically pre ## `src/main/java/hbp/mip/algorithm` -Purpose: Exaflow analysis execution (`AnalysisService`, called by `ExperimentService`) and Exaflow specification endpoints (`GET /specifications/{inputdata,preprocessing,algorithms}`). +Purpose: Exaflow analysis execution (`AnalysisExecutionService`, called by `AnalysisService`) and Exaflow specification endpoints (`GET /specifications/{inputdata,preprocessing,algorithms}`). -Key files: `AnalysisService.java`, `AnalysisRequestDTO.java`, `SpecificationsAPI.java`, `SpecificationsService.java`, specification DTOs. +Key files: `AnalysisExecutionService.java`, `AnalysisRequestDTO.java`, `SpecificationsAPI.java`, `SpecificationsService.java`, specification DTOs. -Used by: The UI and notebook client for specifications; `ExperimentService` for experiment previews and runs. +Used by: The UI and notebook client for specifications; `AnalysisService` for analysis previews and runs. Rules: Keep Exaflow calls in the service layer. Dataset access checks must cover `inputdata.allDatasets()` (datasets plus validation datasets). -Tests: `AnalysisServiceRequestIdTest`, `AnalysisRequestDTODeserializationTest`, `AlgorithmSpecificationDTOTest`, `ExaflowKMeansAndSmdContractTest`, `ExaflowPcaCreatorContractTest`. +Tests: `AnalysisExecutionServiceRequestIdTest`, `AnalysisRequestDTODeserializationTest`, `AlgorithmSpecificationDTOTest`, `ExaflowKMeansAndSmdContractTest`, `ExaflowPcaCreatorContractTest`. ## `src/main/java/hbp/mip/datamodel` @@ -47,7 +47,7 @@ Purpose: Data model and dataset metadata API. Key files: `DataModelAPI.java`, `DataModelService.java`, `DataModelDTO.java`. -Used by: Clients discovering available pathologies, variables, datasets, and metadata. +Used by: Clients discovering available data models, variables, datasets, and metadata. Rules: Preserve claim-based filtering when authentication is enabled. @@ -55,59 +55,51 @@ Tests: Cover Exaflow response parsing, empty responses, and authorization filter Notes: Data comes from multiple configured Exaflow endpoints and is aggregated in service code. -## `src/main/java/hbp/mip/experiment` +## `src/main/java/hbp/mip/analysis` -Purpose: Experiment lifecycle API, business logic, persistence entity, repository, and query specifications. +Purpose: Platform Analysis management, synchronous preview/run/save, persistence, and query specifications. -Key files: `ExperimentAPI.java`, `ExperimentService.java`, `ExperimentRepository.java`, `ExperimentDAO.java`, `ExperimentSpecifications.java`, `ExperimentRunDAO.java`, `ExperimentRunRepository.java`. +Rules: Keep ownership/shared access checks, filtering before pagination/totals, max page size, immutable request fields, and raw result serialization. Complete execution requests use `analysisRequest` in Java/HTTP and `analysis_request` in both `analysis` and `analysis_run`; algorithm names remain in `algorithm_id`. -Used by: Clients creating, listing, updating, deleting, and running experiments. - -Rules: Preserve ownership/shared access checks, max page size behavior, immutable field validation, and Flyway-backed schema compatibility. - -Tests: Add service/repository tests for behavior changes and migration checks for schema changes. - -Notes: Every analysis executes synchronously through `/experiments/preview` or `/experiments/runs`; saving never calls Exaflow. The `analysis` column of `experiment` and `experiment_run` holds the `AnalysisRequestDTO` JSON; the algorithm name is in `algorithm_id`. - -``` -POST /experiments/preview -> 200 experiment { name, analysis } (compute and return, nothing stored) -POST /experiments/runs -> 200 experiment { name, analysis } (compute and keep; uuid is the run id) -POST /experiments -> 201 experiment { runId, name } (save the kept run, no Exaflow call) +```text +GET /analyses -> { analyses, currentPage, totalPages, totalAnalyses } +POST /analyses/preview -> 200 Analysis { name, analysisRequest } (no persistence) +POST /analyses/runs -> 200 Analysis { name, analysisRequest } (retain success; uuid is runId) +POST /analyses -> 201 Analysis { runId, name } (save without execution) +GET/PATCH/DELETE /analyses/{uuid} ``` -A successful run is stored in `experiment_run` for `experiments.run-draft-ttl` (`EXPERIMENT_RUN_DRAFT_TTL`, default `PT24H`); rows older than that are purged whenever a new run is kept. Saving without a `runId` or `name` returns 400; a run that is missing, expired or owned by another user returns 404. The saved experiment keeps the run's `created`/`finished` times and MIP version. +All paths are under `/services`. PATCH permits name, shared, and viewed; the execution request is immutable. Successful runs remain owner-only in `analysis_run` for `analyses.run-draft-ttl` (`ANALYSIS_RUN_DRAFT_TTL`, default `PT24H`). Cleanup is opportunistic on successful runs. Save requires runId and name (400); missing, expired, or another user's draft is 404. Save copies the stored request, result, timestamps, and MIP version without rechecking dataset access, and does not consume the draft. -## `src/main/java/hbp/mip/folder` +Others may read shared Analyses only when authorized for every selected dataset, including validation datasets. Owners and `research_experiment_all` retain their existing access. Only owners may update/delete. Lists enforce the same visibility before counting. -Purpose: Experiment folders ("analysis sets") and the named subsets ("sets") inside them: what the experiments dashboard curates. +Tests: `AnalysisAPITest`, `AnalysisDTOResultTest`, `AnalysisServiceRunSaveTest`, `AnalysisServiceSharedAccessTest`, and `BackendPersistenceIT`. -Key files: `ExperimentFolderAPI.java`, `ExperimentFolderService.java`, `ExperimentFolderRepository.java`, `ExperimentFolderDAO.java`, `ExperimentSetDAO.java`, `ExperimentFolderMemberDAO.java`, and the folder `*DTO` records. +## `src/main/java/hbp/mip/study` -Used by: the frozen frontend contract, all under the `/services` context: +Purpose: Owner-scoped Studies, Analysis Groups, and ordered Study Members. ```text -GET /experiment-folders -> 200 { folders: [folder] } -POST /experiment-folders -> 201 folder { name, experimentUuid? } -GET /experiment-folders/{folderId} -> 200 folder -PATCH /experiment-folders/{folderId} -> 200 folder { name } -DELETE /experiment-folders/{folderId} -> 204 -POST /experiment-folders/{folderId}/members -> 200 folder { experimentUuid } -DELETE /experiment-folders/{folderId}/members/{uuid} -> 200 folder -POST /experiment-folders/{folderId}/sets -> 201 folder { name, experimentUuid? } -PATCH /experiment-folders/{folderId}/sets/{setId} -> 200 folder { name } -DELETE /experiment-folders/{folderId}/sets/{setId} -> 200 folder -PATCH /experiment-folders/{folderId}/members/{uuid}/set -> 200 folder { setId: "uuid" | null } - -folder = { id, name, experimentIds: [uuid], sets: [ { id, name, experimentIds: [uuid] } ] } +GET /studies -> 200 { studies: [study] } +POST /studies -> 201 study { name, analysisId? } +GET /studies/{studyId} -> 200 study +PATCH /studies/{studyId} -> 200 study { name } +DELETE /studies/{studyId} -> 204 +POST /studies/{studyId}/members -> 200 study { analysisId } +DELETE /studies/{studyId}/members/{analysisId} -> 200 study +POST /studies/{studyId}/groups -> 201 study { name, analysisId? } +PATCH /studies/{studyId}/groups/{groupId} -> 200 study { name } +DELETE /studies/{studyId}/groups/{groupId} -> 200 study +PATCH /studies/{studyId}/members/{analysisId}/group -> 200 study { groupId: uuid | null } + +study = { id, name, analysisIds, groups: [{ id, name, analysisIds }] } ``` -A null `setId` ungroups without leaving the folder. Everything but `DELETE /{folderId}` answers with the updated folder, so the caller never rebuilds ordering or partitioning locally. - -Rules: Scope every read and write to the user resolved from the token; a folder owned by somebody else answers 404, never 403. Member and set writes load the folder with `findByIdForUpdate` (`PESSIMISTIC_WRITE`) before the membership check, so concurrent adds/moves on one folder serialize and the member unique constraint stays a backstop, not the thing that decides the request. Write through `saveAndFlush` and translate a unique name violation into 409 — the name pre-check alone cannot win a race between two tabs. Keep one member row per (folder, experiment) — that is what makes sets a strict partition. Names follow the frontend rules: collapse whitespace, trim, 60 chars, unique per owner (and per folder, for sets) ignoring case. Preserve the position columns (`sort_order`, `folder_position`, `set_position`); they are the order the dashboard renders. Deleting a folder or a set never deletes the runs. +One membership row per `(study_id, analysis_id)` gives at most one group per Study. An Analysis can belong to multiple Studies. Null/blank groupId ungroups without leaving the Study; deleting a group leaves its members ungrouped. Deleting a Study never deletes Analyses. Mutations return the updated Study, except Study deletion. -Tests: `ExperimentFolderServiceTest` (Mockito) covers naming, ownership, membership, ordering, and the lost-race 409; `ExperimentFolderDTOTest` covers the three orderings in the response; `ExperimentFolderAPITest` (standalone MockMvc) pins the wire contract — body field names, response field names, and the status of every failure. +Preserve owner scoping (foreign Study/group is 404), Analysis read checks (403), normalization (collapse whitespace, trim, 60 characters), case-insensitive name uniqueness (409), transaction boundaries, write locks, and idempotent add/move/remove operations. Members use `study_position`, group members use `group_position`, and Studies/groups use `sort_order`. -Notes: Folders hold experiment ids, never experiment copies, so nothing here can go stale by carrying a run's data. Statuses: 200 reads and mutations that leave a folder behind, 201 new folder or set, 204 only `DELETE /{folderId}`, 400 blank name or malformed id, 404 folder/set not the caller's or run not readable, 403 run not readable, 409 duplicate name (pre-check or lost database race). +Tests: `StudyAPITest`, `StudyServiceTest`, `StudyDTOTest`, and `BackendPersistenceIT`. ## `src/main/java/hbp/mip/user` @@ -141,7 +133,7 @@ Notes: `HTTPUtil` uses `HttpURLConnection`; no dedicated HTTP client abstraction Purpose: Local runtime config, logging config, and database migrations. -Key files: `application.yml`, `log4j2.yml`, `db/migration/V1__InitialSchema.sql`, `db/migration/V2__ExperimentFolders.sql`. +Key files: `application.yml`, `log4j2.yml`, `db/migration/V1__InitialSchema.sql`, `db/migration/V2__Studys.sql`. Used by: Local app runtime and Maven resource packaging. diff --git a/docs/context/risk-register.md b/docs/context/risk-register.md index 5e3f7f60a..7ac014134 100644 --- a/docs/context/risk-register.md +++ b/docs/context/risk-register.md @@ -3,13 +3,13 @@ | Area | Risk | Evidence | Agent guidance | Human review required? | |---|---|---|---|---| | Authentication and OAuth2 | Login, logout, JWT, CSRF, and session behavior can lock users out or weaken protection | `SecurityConfiguration.java`, `SpaRedirectAuthenticationSuccessHandler.java`, `FrontendRedirectCaptureFilter.java` | Add focused tests and manually review auth flows before changing | Yes | -| Authority and claim mapping | Dataset/experiment access depends on raw authority strings and Keycloak claims | `SecurityConfiguration.java`, `ClaimUtils.java` | Do not add `ROLE_` prefixes or rename claims without migration/compat notes | Yes | -| Dataset authorization | Users may see unauthorized pathologies or datasets if filtering changes | `DataModelService.java`, `ClaimUtils.java` | Cover authenticated and authentication-disabled behavior | Yes | -| Experiment authorization | Owners/shared/admin-like access rules protect experiment read/update/delete | `ExperimentService.java`, `ExperimentSpecifications.java` | Test owner, shared, not-owner, and all-experiments authority cases. Shared experiments need all their datasets: a row naming none, such as a legacy one, is readable only by its owner and the all-experiments role. Keep `canRead` and the `experiment_datasets_readable` database function (V5) in step | Yes | -| Experiment deletion | Deletion is destructive and authorization-sensitive | `ExperimentAPI.java`, `ExperimentService.java` | Require focused tests and rollback/restore discussion for behavior changes | Yes | -| Experiment execution | Background thread updates status/result after Exaflow execution | `ExperimentService.java` | Preserve pending/success/error transitions and repository finish behavior | Yes | -| Exaflow external APIs | Runtime depends on external service contracts and availability | `AnalysisService.java`, `SpecificationsService.java`, `DataModelService.java`, `ExperimentService.java`, `HTTPUtil.java` | Mock response codes/bodies and avoid unreviewed wire-shape changes | Yes | -| Database migrations | Schema drift can break startup because Hibernate validates schema | `PersistenceConfiguration.java`, `V1__InitialSchema.sql` | Add new Flyway migrations; verify on PostgreSQL | Yes | +| Authority and claim mapping | Dataset/analysis access depends on raw authority strings and Keycloak claims | `SecurityConfiguration.java`, `ClaimUtils.java` | Do not add `ROLE_` prefixes or rename claims without migration/compat notes | Yes | +| Dataset authorization | Users may see unauthorized data models or datasets if filtering changes | `DataModelService.java`, `ClaimUtils.java` | Cover authenticated and authentication-disabled behavior | Yes | +| Analysis authorization | Owners/shared/admin-like access rules protect analysis read/update/delete | `AnalysisService.java`, `AnalysisSpecifications.java` | Test owner, shared, not-owner, and all-analyses authority cases. Shared analyses need all their datasets: a row naming none, such as a legacy one, is readable only by its owner and the all-analyses role. Keep `canRead` and the `analysis_datasets_readable` database function (V6) in step | Yes | +| Analysis deletion | Deletion is destructive and authorization-sensitive | `AnalysisAPI.java`, `AnalysisService.java` | Require focused tests and rollback/restore discussion for behavior changes | Yes | +| Analysis execution | Synchronous execution retains successful unsaved runs before a separate save | `AnalysisService.java` | Preserve preview/run/save, draft expiry, owner-only drafts, and raw results | Yes | +| Exaflow external APIs | Runtime depends on external service contracts and availability | `AnalysisExecutionService.java`, `SpecificationsService.java`, `DataModelService.java`, `AnalysisService.java`, `HTTPUtil.java` | Mock response codes/bodies and avoid unreviewed wire-shape changes | Yes | +| Database migrations | Schema drift can break JPA queries and startup | `PersistenceConfiguration.java`, `V6__AnalysisStudyTerminology.sql` | Add new Flyway migrations; verify on PostgreSQL | Yes | | Secrets and config | Keycloak, database, registry, and mirror credentials must stay private | `application.yml`, `.github/workflows/*` | Never print or commit secrets; review env/config changes carefully | Yes | | Logging sensitive data | Request bodies, results, or tokens may include sensitive values | `Logger.java`, API/services logging request details | Avoid adding sensitive logs; redact where possible | Yes | | Release publishing | Workflow pushes public/private images on release | `.github/workflows/publish_images.yml` | Review registry targets, tags, cache, and secret usage | Yes | diff --git a/docs/context/testing.md b/docs/context/testing.md index 768caf1c5..808cb05f9 100644 --- a/docs/context/testing.md +++ b/docs/context/testing.md @@ -1,66 +1,41 @@ # Testing -## Detected Test Setup -- No committed `src/test/java` tree was found. -- No `spring-boot-starter-test`, JUnit, Mockito, AssertJ, Surefire, Failsafe, or JaCoCo configuration was found in `pom.xml`. -- `mvn test` is still the baseline Maven test phase and should be run after changes. +## Unit and HTTP contract tests -## Test Directory Structure -Use package-mirroring under: +Use Java 21 and Maven: -```text -src/test/java/hbp/mip -``` - -Recommended naming: - -- `*Test` for unit tests. -- `*IT` for integration tests. - -## Fast Tests ```bash mvn test +mvn clean package ``` -Until test dependencies are added, this may only compile and run an empty test phase. +`src/test/java/hbp/mip` contains JUnit, Mockito, AssertJ, MockMvc, and security tests. Spring Boot test support is already in the build. Unit tests cover Analysis request/result serialization, preview/run/save, draft expiry, sharing and dataset authorization, Study/group operations, data-model listing, Exaflow contracts, and authentication navigation. -## Full Tests -Unknown / TODO: verify once integration tests exist. For database behavior, run relevant tests against PostgreSQL and verify Flyway migrations apply cleanly. +## PostgreSQL integration tests -## Backend Test Guidance -Add focused tests when changing: +The `postgres-integration` profile uses Maven Failsafe to run `*IT` tests during `verify`. PostgreSQL is required; an unavailable database fails the run instead of skipping coverage. No additional Java test dependencies are needed: tests use the existing PostgreSQL JDBC driver, Flyway, Spring JDBC, and JPA. + +Against a disposable local database: + +```bash +mvn -B -ntp -Ppostgres-integration \ + -Dit.database.url=jdbc:postgresql://127.0.0.1:5432/platform_test \ + -Dit.database.username=postgres \ + -Dit.database.password=postgres \ + clean verify +``` -- `SecurityConfiguration`: auth modes, CSRF behavior, JWT authorities, permitted endpoints. -- `ClaimUtils`, `DataModelService`, `ExperimentService`: authorization and data access logic. -- `ExperimentRepository` and DAOs: persistence and schema-sensitive behavior. -- `HTTPUtil` or Exaflow integrations: external response handling and error mapping. -- `ControllerExceptionHandler`: HTTP status and error response mapping. +These are also the profile defaults. The test user needs permission to create/drop schemas. Each test creates a random isolated schema, and cleanup drops that schema after the application context closes. Use a database reserved for tests. -## Fixtures and Mocks -No committed test fixtures or mocks were found. For future tests, prefer: +`BackendPersistenceIT` verifies: -- Mocking Exaflow HTTP responses for service-level tests. -- Using representative DTO payloads near the tests that need them. -- Using PostgreSQL-backed integration tests for migration/schema behavior. +- Fresh Flyway migration through V6 and startup of the real persistence configuration, including package scanning, query parsing, and explicit Hibernate schema validation. +- Populated V5 upgrades preserving every saved-record, unsaved-run, Study, Analysis Group, and membership value, including malformed historical requests, results with explicit nulls/large integers, timestamps, permissions, and ordering. +- Dataset-authorization parity between the old V5 and new V6 SQL functions across selected/validation datasets, missing or malformed input, and mixed case. +- Saving migrated active runs without execution, repeated saves, expiry and owner checks, query filtering before totals, unchanged external claims, and Study/group/deletion operations. -## Under-Tested Critical Paths -- OAuth2/JWT authority mapping and authentication-disabled mode. -- Dataset and experiment authorization checks. -- Experiment creation, background execution, deletion, and immutable-field validation. -- Exaflow metadata aggregation and error handling. -- Flyway migrations and schema validation. -- Logging behavior around request bodies, tokens, and experiment results. +The `backend-tests.yml` workflow runs `clean verify` with this profile, Java 21, and a PostgreSQL service on pull requests and master pushes. -## Validation Matrix +## Review expectations -| Change type | Required validation | -|---|---| -| Documentation-only change | `git diff --check`; optionally `pre-commit run --all-files` | -| Controller/API behavior change | Add or update controller/service tests; run `mvn test`; document request/response impact | -| Service/business logic change | Add focused unit tests; run `mvn test` | -| Database migration | Add new Flyway migration; verify against PostgreSQL; run `mvn test`; document rollback considerations | -| Auth/permission change | Add security/authorization tests; manually review `SecurityConfiguration`, `ClaimUtils`, and affected services | -| Exaflow integration change | Mock success/error responses; run `mvn test`; verify config keys and timeout/error behavior | -| Dependency update | Explain need; run `mvn test` and `mvn clean package`; check Docker build if runtime-related | -| Refactor without behavior change | Run `mvn test`; add characterization tests first if touching high-risk logic | -| Docker/runtime config change | Run `docker build -t hbpmip/platform-backend:testing .`; verify relevant env/template values | +Keep focused HTTP tests for changes to routes, field names, totals, and status codes. Keep service authorization and raw-result tests. Migrations must be new files; do not rename or edit shipped migrations. Review the rename migration and claim handling together with the backend/UI deployment changes. diff --git a/pom.xml b/pom.xml index beb836f2d..c62639d23 100644 --- a/pom.xml +++ b/pom.xml @@ -175,4 +175,37 @@ + + + postgres-integration + + jdbc:postgresql://127.0.0.1:5432/platform_test + postgres + postgres + + + + + org.apache.maven.plugins + maven-failsafe-plugin + + + ${it.database.url} + ${it.database.username} + ${it.database.password} + + + + + + integration-test + verify + + + + + + + + diff --git a/src/main/java/hbp/mip/algorithm/AnalysisService.java b/src/main/java/hbp/mip/algorithm/AnalysisExecutionService.java similarity index 95% rename from src/main/java/hbp/mip/algorithm/AnalysisService.java rename to src/main/java/hbp/mip/algorithm/AnalysisExecutionService.java index 530def238..b1e2fb466 100644 --- a/src/main/java/hbp/mip/algorithm/AnalysisService.java +++ b/src/main/java/hbp/mip/algorithm/AnalysisExecutionService.java @@ -14,7 +14,7 @@ import java.util.UUID; @Service -public class AnalysisService { +public class AnalysisExecutionService { private static final String GENERIC_ERROR_MESSAGE = "Something went wrong. Please inform the system administrator or try again later."; @@ -26,13 +26,13 @@ public class AnalysisService { @Value("${services.exaflow.apiToken:}") private String exaflowApiToken; - public AnalysisService(@Value("${services.exaflow.analysisUrl}") String analysisUrl) { + public AnalysisExecutionService(@Value("${services.exaflow.analysisUrl}") String analysisUrl) { this.analysisUrl = analysisUrl; } /** Rejects with 400 a payload Exaflow cannot run, before any access check or persistence touches it. */ public static void requireRunnable(AnalysisRequestDTO analysisRequest, Logger logger) { - String missing = analysisRequest == null ? "analysis" + String missing = analysisRequest == null ? "analysisRequest" : analysisRequest.algorithm() == null || analysisRequest.algorithm().name() == null ? "algorithm.name" : analysisRequest.inputdata() == null ? "inputdata" : null; diff --git a/src/main/java/hbp/mip/algorithm/AnalysisRequestDTO.java b/src/main/java/hbp/mip/algorithm/AnalysisRequestDTO.java index ab883aee7..55023fe3e 100644 --- a/src/main/java/hbp/mip/algorithm/AnalysisRequestDTO.java +++ b/src/main/java/hbp/mip/algorithm/AnalysisRequestDTO.java @@ -15,12 +15,12 @@ public record AnalysisRequestDTO( AnalysisAlgorithmDTO algorithm, Map flags) { - /** A stored analysis can be an error message, not JSON (see V2 migration); it then reads as no analysis. */ - public static AnalysisRequestDTO fromStored(String analysis) { + /** Historical request text can be an error message; unreadable requests remain absent in the DTO. */ + public static AnalysisRequestDTO fromStored(String analysisRequest) { try { - return JsonConverters.convertJsonStringToObject(analysis, AnalysisRequestDTO.class); + return JsonConverters.convertJsonStringToObject(analysisRequest, AnalysisRequestDTO.class); } catch (JsonParseException e) { - new Logger("unknown", "AnalysisRequestDTO").warn("Stored analysis is unreadable: " + e.getClass().getSimpleName()); + new Logger("unknown", "AnalysisRequestDTO").warn("Stored analysisRequest is unreadable: " + e.getClass().getSimpleName()); return null; } } diff --git a/src/main/java/hbp/mip/analysis/AnalysesDTO.java b/src/main/java/hbp/mip/analysis/AnalysesDTO.java new file mode 100644 index 000000000..457565b02 --- /dev/null +++ b/src/main/java/hbp/mip/analysis/AnalysesDTO.java @@ -0,0 +1,11 @@ +package hbp.mip.analysis; + +import java.util.List; + +public record AnalysesDTO( + List analyses, + Integer currentPage, + Integer totalPages, + Long totalAnalyses +) { +} diff --git a/src/main/java/hbp/mip/analysis/AnalysisAPI.java b/src/main/java/hbp/mip/analysis/AnalysisAPI.java new file mode 100644 index 000000000..9dc6d165c --- /dev/null +++ b/src/main/java/hbp/mip/analysis/AnalysisAPI.java @@ -0,0 +1,146 @@ +package hbp.mip.analysis; + +import hbp.mip.user.ActiveUserService; +import hbp.mip.utils.JsonConverters; +import hbp.mip.utils.Logger; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.security.core.Authentication; +import org.springframework.web.bind.annotation.*; + +import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; + +@RestController +@RequestMapping(value = "/analyses", produces = { APPLICATION_JSON_VALUE }) +public class AnalysisAPI { + + private final AnalysisService analysisService; + private final ActiveUserService activeUserService; + + public AnalysisAPI( + AnalysisService analysisService, + ActiveUserService activeUserService) { + this.analysisService = analysisService; + this.activeUserService = activeUserService; + } + + @GetMapping + public ResponseEntity getAnalyses(Authentication authentication, + @RequestParam(name = "name", required = false) String name, + @RequestParam(name = "algorithm", required = false) String algorithm, + @RequestParam(name = "shared", required = false) Boolean shared, + @RequestParam(name = "viewed", required = false) Boolean viewed, + @RequestParam(name = "includeShared", required = false, defaultValue = "true") boolean includeShared, + @RequestParam(name = "mine", required = false, defaultValue = "false") boolean mine, + @RequestParam(name = "notMine", required = false, defaultValue = "false") boolean notMine, + @RequestParam(name = "orderBy", required = false, defaultValue = "created") String orderBy, + @RequestParam(name = "descending", required = false, defaultValue = "true") Boolean descending, + @RequestParam(defaultValue = "0") int page, + @RequestParam(defaultValue = "10") int size) { + var logger = new Logger(activeUserService.getActiveUser(authentication).username(), "(GET) /analyses"); + logger.info( + "Request for analyses with parameters: " + + "name -> " + name + + " , algorithm -> " + algorithm + + " , shared -> " + shared + + " , viewed -> " + viewed + + " , includeShared -> " + includeShared + + " , mine -> " + mine + + " , notMine -> " + notMine + + " , orderBy -> " + orderBy + + " , descending -> " + descending + + " , page -> " + page + + " , size -> " + size); + var analysesDTO = analysisService.getAnalyses(authentication, + name, + algorithm, + shared, + viewed, + includeShared, + mine, + notMine, + page, + size, + orderBy, + descending, + logger); + logger.info("Analyses returned: " + analysesDTO.analyses().size()); + return new ResponseEntity<>(analysesDTO, HttpStatus.OK); + } + + @GetMapping(value = "/{uuid}") + public ResponseEntity getAnalysis(Authentication authentication, + @PathVariable("uuid") String uuid) { + var logger = new Logger(activeUserService.getActiveUser(authentication).username(), + "(GET) /analyses/" + uuid); + logger.info("Request for analysis with id: " + uuid); + var analysisResponse = analysisService.getAnalysis(authentication, uuid, logger); + logger.info("Analysis returned."); + return new ResponseEntity<>(analysisResponse, HttpStatus.OK); + } + + @PostMapping + public ResponseEntity saveAnalysisRun(Authentication authentication, + @RequestBody SaveAnalysisRunDTO saveAnalysisRunDTO) { + var user = activeUserService.getActiveUser(authentication); + var logger = new Logger(user.username(), "(POST) /analyses"); + logger.info("Request to save analysis run with id: " + saveAnalysisRunDTO.runId()); + var analysisResponse = analysisService.saveAnalysisRun(user, saveAnalysisRunDTO.runId(), + saveAnalysisRunDTO.name(), logger); + logger.info("Analysis run saved. Run id: " + saveAnalysisRunDTO.runId() + ", analysis id: " + + analysisResponse.uuid()); + return new ResponseEntity<>(analysisResponse, HttpStatus.CREATED); + } + + @PatchMapping(value = "/{uuid}") + public ResponseEntity updateAnalysis(Authentication authentication, + @RequestBody AnalysisDTO analysisRequest, @PathVariable("uuid") String uuid) { + var user = activeUserService.getActiveUser(authentication); + var logger = new Logger(user.username(), "(PATCH) /analyses/" + uuid); + logger.info("Request for analysis update with id: " + uuid + ". Request Body: " + + JsonConverters.convertObjectToJsonString(analysisRequest)); + var analysisResponse = analysisService.updateAnalysis(user, uuid, analysisRequest, logger); + logger.info("Analysis updated. Id: " + uuid); + return new ResponseEntity<>(analysisResponse, HttpStatus.OK); + } + + @RequestMapping(value = "/{uuid}", method = RequestMethod.DELETE) + public ResponseEntity deleteAnalysis(Authentication authentication, @PathVariable("uuid") String uuid) { + var user = activeUserService.getActiveUser(authentication); + var logger = new Logger(user.username(), "(DELETE) /analyses/" + uuid); + logger.info("Request for analysis deletion with id: " + uuid); + analysisService.deleteAnalysis(user, uuid, logger); + logger.info("Analysis deleted. Id: " + uuid); + return new ResponseEntity<>(HttpStatus.OK); + } + + @PostMapping(value = "/preview") + public ResponseEntity previewAnalysis(Authentication authentication, + @RequestBody AnalysisExecutionDTO analysisExecutionDTO) { + var logger = new Logger(activeUserService.getActiveUser(authentication).username(), + "(POST) /analyses/preview"); + logger.debug("Request for analysis preview. RequestBody: " + + JsonConverters.convertObjectToJsonString(analysisExecutionDTO)); + + var analysisResponse = analysisService.previewAnalysis(authentication, analysisExecutionDTO, logger); + + logger.info("Analysis preview finished. Status: " + analysisResponse.status()); + return new ResponseEntity<>(analysisResponse, HttpStatus.OK); + } + + @PostMapping(value = "/runs") + public ResponseEntity runAnalysis(Authentication authentication, + @RequestBody AnalysisExecutionDTO analysisExecutionDTO) { + var user = activeUserService.getActiveUser(authentication); + var logger = new Logger(user.username(), "(POST) /analyses/runs"); + logger.debug("Request for analysis run. RequestBody: " + + JsonConverters.convertObjectToJsonString(analysisExecutionDTO)); + + var analysisResponse = analysisService.runAnalysis(authentication, user, analysisExecutionDTO, + logger); + + logger.info("Analysis run finished. Id: " + analysisResponse.uuid() + + " Status: " + analysisResponse.status()); + return new ResponseEntity<>(analysisResponse, HttpStatus.OK); + } +} diff --git a/src/main/java/hbp/mip/experiment/ExperimentDAO.java b/src/main/java/hbp/mip/analysis/AnalysisDAO.java similarity index 85% rename from src/main/java/hbp/mip/experiment/ExperimentDAO.java rename to src/main/java/hbp/mip/analysis/AnalysisDAO.java index 75f1e3082..d6ac337dd 100644 --- a/src/main/java/hbp/mip/experiment/ExperimentDAO.java +++ b/src/main/java/hbp/mip/analysis/AnalysisDAO.java @@ -1,4 +1,4 @@ -package hbp.mip.experiment; +package hbp.mip.analysis; import hbp.mip.user.UserDAO; import jakarta.persistence.*; @@ -11,8 +11,8 @@ @Entity @Data @NoArgsConstructor -@Table(name = "`experiment`") -public class ExperimentDAO { +@Table(name = "`analysis`") +public class AnalysisDAO { @Id @Column(columnDefinition = "uuid", updatable = false) @@ -36,8 +36,8 @@ public class ExperimentDAO { private Date finished; // The AnalysisRequestDTO the result was computed from, as JSON. - @Column(columnDefinition = "TEXT") - private String analysis; + @Column(name = "analysis_request", columnDefinition = "TEXT") + private String analysisRequest; @Column(name = "algorithm_id", columnDefinition = "TEXT") private String algorithmId; @@ -54,7 +54,7 @@ public class ExperimentDAO { @Column(name = "mip_version", columnDefinition = "TEXT") private String mipVersion; - // Whether the experiment's result have been viewed by its owner + // Whether the analysis's result have been viewed by its owner @Column(columnDefinition = "BOOLEAN") private boolean viewed = false; diff --git a/src/main/java/hbp/mip/analysis/AnalysisDTO.java b/src/main/java/hbp/mip/analysis/AnalysisDTO.java new file mode 100644 index 000000000..17cb094b4 --- /dev/null +++ b/src/main/java/hbp/mip/analysis/AnalysisDTO.java @@ -0,0 +1,38 @@ +package hbp.mip.analysis; + +import hbp.mip.algorithm.AnalysisRequestDTO; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.RawJson; + +import java.util.Date; +import java.util.UUID; + +public record AnalysisDTO( + UUID uuid, + String name, + UserDTO createdBy, + Date created, + Date updated, + Date finished, + Boolean shared, + Boolean viewed, + Object result, + AnalysisDAO.Status status, + AnalysisRequestDTO analysisRequest, + String mipVersion) { + public AnalysisDTO(AnalysisDAO analysisDAO, boolean includeResult) { + this( + analysisDAO.getUuid(), + analysisDAO.getName(), + new UserDTO(analysisDAO.getCreatedBy()), + analysisDAO.getCreated(), + analysisDAO.getUpdated(), + analysisDAO.getFinished(), + analysisDAO.isShared(), + analysisDAO.isViewed(), + includeResult && analysisDAO.getResult() != null ? new RawJson(analysisDAO.getResult()) : null, + analysisDAO.getStatus(), + AnalysisRequestDTO.fromStored(analysisDAO.getAnalysisRequest()), + analysisDAO.getMipVersion()); + } +} diff --git a/src/main/java/hbp/mip/analysis/AnalysisExecutionDTO.java b/src/main/java/hbp/mip/analysis/AnalysisExecutionDTO.java new file mode 100644 index 000000000..fb339fd26 --- /dev/null +++ b/src/main/java/hbp/mip/analysis/AnalysisExecutionDTO.java @@ -0,0 +1,8 @@ +package hbp.mip.analysis; + +import hbp.mip.algorithm.AnalysisRequestDTO; + +public record AnalysisExecutionDTO( + String name, + AnalysisRequestDTO analysisRequest) { +} diff --git a/src/main/java/hbp/mip/analysis/AnalysisRepository.java b/src/main/java/hbp/mip/analysis/AnalysisRepository.java new file mode 100644 index 000000000..e691a4f98 --- /dev/null +++ b/src/main/java/hbp/mip/analysis/AnalysisRepository.java @@ -0,0 +1,67 @@ +package hbp.mip.analysis; + +import hbp.mip.user.UserDAO; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.Exceptions.BadRequestException; +import hbp.mip.utils.Exceptions.AnalysisNotFoundException; +import hbp.mip.utils.Logger; +import org.springframework.data.jpa.repository.JpaSpecificationExecutor; +import org.springframework.data.repository.CrudRepository; + +import java.util.UUID; + +public interface AnalysisRepository + extends CrudRepository, JpaSpecificationExecutor { + AnalysisDAO findByUuid(UUID analysisId); + + static UUID parseUuid(String uuid, Logger logger) { + try { + return UUID.fromString(uuid); + } catch (IllegalArgumentException e) { + logger.error("Conversion of string to UUID failed:" + e.getMessage()); + throw new BadRequestException(e.getMessage()); + } + } + + default AnalysisDAO loadAnalysis(String uuid, Logger logger) { + UUID analysisId = parseUuid(uuid, logger); + + AnalysisDAO analysisDAO = findByUuid(analysisId); + if (analysisDAO == null) { + var errorMessage = "Analysis with uuid : " + uuid + "was not found."; + logger.warn(errorMessage); + throw new AnalysisNotFoundException(errorMessage); + } + + return analysisDAO; + } + + /** + * Persists a kept run as a finished analysis. Everything describing the run (analysisRequest, result, + * when it started and finished, which MIP version computed it) is copied unchanged; only the + * identity, owner and name are new, so one run can be saved more than once. + */ + default AnalysisDAO createAnalysisFromRun(AnalysisRunDAO run, String name, UserDTO user, + Logger logger) { + AnalysisDAO analysisDAO = new AnalysisDAO(); + + analysisDAO.setUuid(UUID.randomUUID()); + analysisDAO.setCreatedBy(new UserDAO(user)); + analysisDAO.setAnalysisRequest(run.getAnalysisRequest()); + analysisDAO.setAlgorithmId(run.getAlgorithmId()); + analysisDAO.setName(name); + analysisDAO.setMipVersion(run.getMipVersion()); + analysisDAO.setStatus(AnalysisDAO.Status.success); + analysisDAO.setResult(run.getResult()); + analysisDAO.setCreated(run.getCreated()); + analysisDAO.setFinished(run.getFinished()); + + try { + save(analysisDAO); + } catch (Exception e) { + logger.error("Failed to save to the database: " + e.getMessage()); + throw e; + } + return analysisDAO; + } +} diff --git a/src/main/java/hbp/mip/experiment/ExperimentRunDAO.java b/src/main/java/hbp/mip/analysis/AnalysisRunDAO.java similarity index 77% rename from src/main/java/hbp/mip/experiment/ExperimentRunDAO.java rename to src/main/java/hbp/mip/analysis/AnalysisRunDAO.java index 9fd473bbe..ff393df31 100644 --- a/src/main/java/hbp/mip/experiment/ExperimentRunDAO.java +++ b/src/main/java/hbp/mip/analysis/AnalysisRunDAO.java @@ -1,4 +1,4 @@ -package hbp.mip.experiment; +package hbp.mip.analysis; import jakarta.persistence.*; import lombok.Data; @@ -9,14 +9,14 @@ /** * A successful studio run kept until its owner saves it or it expires. Saving copies it into an - * {@link ExperimentDAO}, so the stored result is the one the user reviewed and the analysis is not + * {@link AnalysisDAO}, so the stored result is the one the user reviewed and the analysisRequest is not * executed again. */ @Entity @Data @NoArgsConstructor -@Table(name = "experiment_run") -public class ExperimentRunDAO { +@Table(name = "analysis_run") +public class AnalysisRunDAO { @Id @Column(columnDefinition = "uuid", updatable = false) @@ -29,8 +29,8 @@ public class ExperimentRunDAO { private String result; // The AnalysisRequestDTO the result was computed from, as JSON. - @Column(columnDefinition = "TEXT") - private String analysis; + @Column(name = "analysis_request", columnDefinition = "TEXT") + private String analysisRequest; @Column(name = "algorithm_id", columnDefinition = "TEXT") private String algorithmId; diff --git a/src/main/java/hbp/mip/experiment/ExperimentRunRepository.java b/src/main/java/hbp/mip/analysis/AnalysisRunRepository.java similarity index 72% rename from src/main/java/hbp/mip/experiment/ExperimentRunRepository.java rename to src/main/java/hbp/mip/analysis/AnalysisRunRepository.java index 11b664074..67ee6316e 100644 --- a/src/main/java/hbp/mip/experiment/ExperimentRunRepository.java +++ b/src/main/java/hbp/mip/analysis/AnalysisRunRepository.java @@ -1,4 +1,4 @@ -package hbp.mip.experiment; +package hbp.mip.analysis; import org.springframework.data.jpa.repository.Modifying; import org.springframework.data.jpa.repository.Query; @@ -9,11 +9,11 @@ import java.util.Date; import java.util.UUID; -public interface ExperimentRunRepository extends CrudRepository { +public interface AnalysisRunRepository extends CrudRepository { // A bulk delete, so expired results are never loaded just to be removed. @Transactional @Modifying - @Query("delete from ExperimentRunDAO run where run.created < :cutoff") + @Query("delete from AnalysisRunDAO run where run.created < :cutoff") int deleteCreatedBefore(@Param("cutoff") Date cutoff); } diff --git a/src/main/java/hbp/mip/analysis/AnalysisService.java b/src/main/java/hbp/mip/analysis/AnalysisService.java new file mode 100644 index 000000000..f294b56cf --- /dev/null +++ b/src/main/java/hbp/mip/analysis/AnalysisService.java @@ -0,0 +1,386 @@ +package hbp.mip.analysis; + +import hbp.mip.algorithm.AnalysisRequestDTO; +import hbp.mip.algorithm.AnalysisExecutionService; +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.*; +import hbp.mip.utils.Exceptions.*; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.data.domain.*; +import org.springframework.data.jpa.domain.Specification; +import org.springframework.security.core.Authentication; +import org.springframework.stereotype.Service; + +import java.time.Duration; +import java.util.*; + +import static hbp.mip.utils.JsonConverters.convertObjectToJsonString; + +@Service +public class AnalysisService { + + private static final int MAX_PAGE_SIZE = 50; + + private final ActiveUserService activeUserService; + private final ClaimUtils claimUtils; + private final AnalysisRepository analysisRepository; + private final AnalysisRunRepository analysisRunRepository; + private final AnalysisExecutionService analysisExecutionService; + private final boolean authenticationIsEnabled; + private final String mipVersion; + private final Duration runDraftTtl; + + public AnalysisService( + ActiveUserService activeUserService, + ClaimUtils claimUtils, + AnalysisRepository analysisRepository, + AnalysisRunRepository analysisRunRepository, + AnalysisExecutionService analysisExecutionService, + @Value("${authentication.enabled}") boolean authenticationIsEnabled, + @Value("${mip.version}") String mipVersion, + @Value("${analyses.run-draft-ttl}") Duration runDraftTtl) { + this.activeUserService = activeUserService; + this.claimUtils = claimUtils; + this.analysisRepository = analysisRepository; + this.analysisRunRepository = analysisRunRepository; + this.analysisExecutionService = analysisExecutionService; + this.authenticationIsEnabled = authenticationIsEnabled; + this.mipVersion = mipVersion; + this.runDraftTtl = runDraftTtl; + } + + public AnalysesDTO getAnalyses(Authentication authentication, String name, String algorithm, Boolean shared, + Boolean viewed, boolean includeShared, boolean mine, boolean notMine, int page, int size, String orderBy, + Boolean descending, + Logger logger) { + validatePageSize(size); + + Specification spec = buildAnalysisSpecification(authentication, name, algorithm, shared, + viewed, includeShared, mine, notMine, orderBy, descending, logger); + Pageable pageable = PageRequest.of(page, size); + Page analysesPage = analysisRepository.findAll(spec, pageable); + + if (analysesPage.isEmpty()) { + throw new NoContent("No analysis found with the filters provided."); + } + + return createAnalysesDTO(analysesPage); + } + + private void validatePageSize(int size) { + if (size > MAX_PAGE_SIZE) { + throw new BadRequestException("Invalid size input, max size is " + MAX_PAGE_SIZE); + } + } + + private Specification buildAnalysisSpecification(Authentication authentication, String name, + String algorithm, Boolean shared, Boolean viewed, boolean includeShared, boolean mine, boolean notMine, + String orderBy, + Boolean descending, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + boolean hasAccessRights = !authenticationIsEnabled + || claimUtils.validateAccessRightsOnALLAnalyses(authentication, logger); + + Specification spec; + + if (mine) { + spec = Specification.where(new AnalysisSpecifications.MyAnalysis(user.username())); + } else if (notMine) { + spec = Specification.where(new AnalysisSpecifications.NotMyAnalysis(user.username())) + .and(sharedAndReadable(authentication, true, hasAccessRights, logger)); + } else if (hasAccessRights) { + spec = (root, query, criteriaBuilder) -> criteriaBuilder.conjunction(); + } else { + spec = Specification.where(new AnalysisSpecifications.MyAnalysis(user.username())) + .or(sharedAndReadable(authentication, includeShared, hasAccessRights, logger)); + } + + return spec + .and(new AnalysisSpecifications.AnalysisWithName(name)) + .and(new AnalysisSpecifications.AnalysisWithAlgorithm(algorithm)) + .and(new AnalysisSpecifications.AnalysisWithShared(shared)) + .and(new AnalysisSpecifications.AnalysisWithViewed(viewed)) + .and(new AnalysisSpecifications.AnalysisOrderBy(orderBy, descending)); + } + + // canRead's rule for lists, in the query: filtering afterwards would let totals and filters reveal hidden analyses. + private Specification sharedAndReadable(Authentication authentication, boolean shared, + boolean hasAccessRights, Logger logger) { + Specification spec = new AnalysisSpecifications.SharedAnalysis(shared); + List datasets = hasAccessRights ? null : claimUtils.usableDatasets(authentication, logger); + return datasets == null + ? spec + : spec.and(new AnalysisSpecifications.DatasetsReadable(convertObjectToJsonString(datasets))); + } + + private AnalysesDTO createAnalysesDTO(Page pageAnalyses) { + List analyses = pageAnalyses.map(analysisDAO -> new AnalysisDTO(analysisDAO, false)) + .getContent(); + return new AnalysesDTO(analyses, pageAnalyses.getNumber(), pageAnalyses.getTotalPages(), + pageAnalyses.getTotalElements()); + } + + public AnalysisDTO getAnalysis(Authentication authentication, String uuid, Logger logger) { + AnalysisDAO analysisDAO = assertAnalysisAccessible(authentication, uuid, logger); + + return new AnalysisDTO(analysisDAO, true); + } + + /** + * Loads an analysis and refuses it when the active user may not read it, returning the entity so + * other features can reference a run they are allowed to see. + * + * Feature code that only needs to know "is this run usable by this user" should call this instead + * of reopening the access rules, which live in one place on purpose. + */ + public AnalysisDAO assertAnalysisAccessible(Authentication authentication, String uuid, Logger logger) { + AnalysisDAO analysisDAO = analysisRepository.loadAnalysis(uuid, logger); + validateAnalysisAccess(authentication, analysisDAO, uuid, logger); + + return analysisDAO; + } + + private void validateAnalysisAccess(Authentication authentication, AnalysisDAO analysisDAO, String uuid, + Logger logger) { + var user = activeUserService.getActiveUser(authentication); + + if (!canRead(authentication, user, analysisDAO, logger)) { + logger.warn("User tried to access an unauthorized analysis with id:" + uuid); + throw new UnauthorizedException("You don't have access to that analysis."); + } + } + + /** Sharing an analysis does not open its data: others also need the datasets it ran on. */ + private boolean canRead(Authentication authentication, UserDTO user, AnalysisDAO analysisDAO, Logger logger) { + if (!authenticationIsEnabled + || analysisDAO.getCreatedBy().getUsername().equals(user.username()) + || claimUtils.validateAccessRightsOnALLAnalyses(authentication, logger)) { + return true; + } + return analysisDAO.isShared() + && claimUtils.hasAccessRightsOnDatasets(authentication, datasetsOf(analysisDAO), logger); + } + + private static List datasetsOf(AnalysisDAO analysisDAO) { + AnalysisRequestDTO analysisRequest = AnalysisRequestDTO.fromStored(analysisDAO.getAnalysisRequest()); + return analysisRequest != null && analysisRequest.inputdata() != null ? analysisRequest.inputdata().allDatasets() : null; + } + + private void validateDatasetAccess(Authentication authentication, AnalysisRequestDTO analysisRequest, Logger logger) { + if (authenticationIsEnabled) { + claimUtils.validateAccessRightsOnDatasets(authentication, analysisRequest.inputdata().allDatasets(), logger); + } + } + + /** Runs an analysis and returns its result without storing anything. */ + public AnalysisDTO previewAnalysis(Authentication authentication, + AnalysisExecutionDTO analysisExecutionDTO, Logger logger) { + AnalysisExecutionService.requireRunnable(analysisExecutionDTO.analysisRequest(), logger); + analysisRequestParametersLogging(analysisExecutionDTO, logger); + + validateDatasetAccess(authentication, analysisExecutionDTO.analysisRequest(), logger); + UUID uuid = UUID.randomUUID(); + AnalysisExecutionService.AnalysisResultDTO analysisResult = analysisExecutionService.runAnalysis( + uuid, + analysisExecutionDTO.analysisRequest(), + logger); + + return new AnalysisDTO(uuid, analysisExecutionDTO.name(), null, null, null, null, null, null, + analysisResult.body(), + analysisResult.code() >= 400 ? AnalysisDAO.Status.error : AnalysisDAO.Status.success, + analysisExecutionDTO.analysisRequest(), + mipVersion); + } + + /** + * Runs an analysis like {@link #previewAnalysis} and, when it succeeds, keeps the result so + * {@link #saveAnalysisRun} can persist it later without executing the analysis again. The + * returned uuid is the run id to save. + */ + public AnalysisDTO runAnalysis(Authentication authentication, UserDTO user, + AnalysisExecutionDTO analysisExecutionDTO, Logger logger) { + Date started = new Date(); + AnalysisDTO run = previewAnalysis(authentication, analysisExecutionDTO, logger); + if (run.status() == AnalysisDAO.Status.success) { + keepRun(run, analysisExecutionDTO.analysisRequest(), started, user, logger); + } + return run; + } + + private void keepRun(AnalysisDTO run, AnalysisRequestDTO analysisRequest, Date started, UserDTO user, + Logger logger) { + AnalysisRunDAO runDAO = new AnalysisRunDAO(); + runDAO.setUuid(run.uuid()); + runDAO.setCreatedByUsername(user.username()); + runDAO.setAnalysisRequest(convertObjectToJsonString(analysisRequest)); + runDAO.setAlgorithmId(analysisRequest.algorithm().name()); + runDAO.setResult(convertObjectToJsonString(run.result())); + runDAO.setCreated(started); + runDAO.setFinished(new Date()); + runDAO.setMipVersion(mipVersion); + + // Purging is housekeeping; a failure here must not stop this run from being kept. + try { + analysisRunRepository.deleteCreatedBefore(runDraftCutoff()); + } catch (Exception e) { + logger.warn("Failed to purge expired runs: " + e.getMessage()); + } + + // The result is still returned when it cannot be kept; saving it later then reports it as missing. + try { + analysisRunRepository.save(runDAO); + } catch (Exception e) { + logger.error("Failed to keep the run in the database: " + e.getMessage()); + } + } + + /** + * Persists a run kept by {@link #runAnalysis} as an analysis of the active user. The stored + * analysisRequest and result are the ones the run produced; nothing is sent to Exaflow. + */ + public AnalysisDTO saveAnalysisRun(UserDTO user, String runId, String name, Logger logger) { + if (name == null || name.isBlank()) { + throw new BadRequestException("An analysis name is required."); + } + if (runId == null || runId.isBlank()) { + throw new BadRequestException("A runId is required."); + } + + // Dataset access was validated when the run executed; the kept run is owner-only, so it is not checked again. + AnalysisRunDAO run = loadKeptRun(runId, user, logger); + + AnalysisDAO analysisDAO = analysisRepository.createAnalysisFromRun(run, name.trim(), user, logger); + return new AnalysisDTO(analysisDAO, false); + } + + private AnalysisRunDAO loadKeptRun(String runId, UserDTO user, Logger logger) { + // Another user's run reads as missing, so run ids cannot be probed. + return analysisRunRepository.findById(AnalysisRepository.parseUuid(runId, logger)) + .filter(run -> run.getCreatedByUsername().equals(user.username())) + .filter(run -> !run.getCreated().before(runDraftCutoff())) + .orElseThrow(() -> { + logger.warn("Run to save was not found or has expired. Id: " + runId); + return new AnalysisNotFoundException( + "This run is no longer available to save. Run the analysis again."); + }); + } + + private Date runDraftCutoff() { + return new Date(System.currentTimeMillis() - runDraftTtl.toMillis()); + } + + public AnalysisDTO updateAnalysis(UserDTO user, String uuid, AnalysisDTO analysis, Logger logger) { + AnalysisDAO analysisDAO = analysisRepository.loadAnalysis(uuid, logger); + + verifyNonEditableFieldsAreNotBeingModified(analysis, logger); + checkUpdateAuthorization(user, analysisDAO, uuid, logger); + + updateModifiableFields(analysis, analysisDAO); + analysisDAO.setUpdated(new Date()); + + try { + analysisRepository.save(analysisDAO); + } catch (Exception e) { + logger.error("Failed to save to the database: " + e.getMessage()); + throw new InternalServerError(e.getMessage()); + } + + return new AnalysisDTO(analysisDAO, true); + } + + private void checkUpdateAuthorization(UserDTO user, AnalysisDAO analysisDAO, String uuid, Logger logger) { + if (!analysisDAO.getCreatedBy().getUsername().equals(user.username())) { + logger.warn("User tried to modify an unauthorized analysis with uuid: " + uuid); + throw new UnauthorizedException("You don't have access to modify the analysis."); + } + } + + private void updateModifiableFields(AnalysisDTO analysis, AnalysisDAO analysisDAO) { + if (analysis.name() != null && !analysis.name().isEmpty()) { + analysisDAO.setName(analysis.name()); + } + if (analysis.shared() != null) { + analysisDAO.setShared(analysis.shared()); + } + if (analysis.viewed() != null) { + analysisDAO.setViewed(analysis.viewed()); + } + } + + public void deleteAnalysis(UserDTO user, String uuid, Logger logger) { + AnalysisDAO analysisDAO = analysisRepository.loadAnalysis(uuid, logger); + + checkDeleteAuthorization(user, analysisDAO, uuid, logger); + + try { + analysisRepository.delete(analysisDAO); + } catch (Exception e) { + logger.info("Attempted to delete an analysis from the database but an error occurred: " + e.getMessage()); + throw new InternalServerError(e.getMessage()); + } + } + + private void checkDeleteAuthorization(UserDTO user, AnalysisDAO analysisDAO, String uuid, Logger logger) { + if (!analysisDAO.getCreatedBy().getUsername().equals(user.username())) { + logger.warn("User " + user.username() + " tried to delete the analysis with uuid " + uuid + + " but was unauthorized."); + throw new UnauthorizedException("You don't have access to delete the analysis."); + } + } + + private void verifyNonEditableFieldsAreNotBeingModified(AnalysisDTO analysisDTO, Logger logger) { + throwIfNonNull(analysisDTO.uuid(), "uuid", logger); + throwIfNonNull(analysisDTO.createdBy(), "createdBy", logger); + throwIfNonNull(analysisDTO.created(), "created", logger); + throwIfNonNull(analysisDTO.updated(), "updated", logger); + throwIfNonNull(analysisDTO.finished(), "finished", logger); + throwIfNonNull(analysisDTO.result(), "result", logger); + throwIfNonNull(analysisDTO.status(), "status", logger); + throwIfNonNull(analysisDTO.analysisRequest(), "analysisRequest", logger); + } + + private void throwIfNonNull(Object field, String nonEditableField, Logger logger) { + if (field != null) { + String errorMessage = "Tried to edit non-editable field: " + nonEditableField; + logger.warn(errorMessage); + throw new BadRequestException(errorMessage); + } + } + + private void analysisRequestParametersLogging(AnalysisExecutionDTO analysisExecutionDTO, Logger logger) { + AnalysisRequestDTO analysisRequest = analysisExecutionDTO.analysisRequest(); + StringBuilder parametersLogMessage = new StringBuilder(); + + Optional.ofNullable(analysisRequest.algorithm().parameters()).ifPresent(parameters -> parameters.forEach((paramName, + paramValue) -> parametersLogMessage.append(" ").append(paramName).append(" -> ").append(paramValue))); + + Optional.ofNullable(analysisRequest.preprocessing()).ifPresent(preprocessing -> preprocessing + .forEach(step -> parametersLogMessage.append(" ").append(step.name()).append(" -> ") + .append(step.parameters()))); + + if (analysisRequest.inputdata() != null) { + AnalysisRequestDTO.AnalysisInputDataDTO inputData = analysisRequest.inputdata(); + parametersLogMessage.append(" Input Data Model: ").append(inputData.data_model()); + + Optional.ofNullable(inputData.datasets()) + .ifPresent(datasets -> parametersLogMessage.append(" Datasets: ").append(datasets)); + + Optional.ofNullable(inputData.variables()) + .ifPresent(variables -> parametersLogMessage.append(" Variables: ").append(variables)); + + Optional.ofNullable(analysisRequest.algorithm().x()) + .ifPresent(xVars -> parametersLogMessage.append(" X Variables: ").append(xVars)); + + Optional.ofNullable(analysisRequest.algorithm().y()) + .ifPresent(yVars -> parametersLogMessage.append(" Y Variables: ").append(yVars)); + + if (inputData.filters() != null) { + parametersLogMessage.append(" Filters: ").append(inputData.filters()); + } + } + + logger.debug("Analysis " + analysisRequest.algorithm().name() + " execution starting with parameters: " + + parametersLogMessage); + } +} diff --git a/src/main/java/hbp/mip/experiment/ExperimentSpecifications.java b/src/main/java/hbp/mip/analysis/AnalysisSpecifications.java similarity index 58% rename from src/main/java/hbp/mip/experiment/ExperimentSpecifications.java rename to src/main/java/hbp/mip/analysis/AnalysisSpecifications.java index 74226e300..11b3a2563 100644 --- a/src/main/java/hbp/mip/experiment/ExperimentSpecifications.java +++ b/src/main/java/hbp/mip/analysis/AnalysisSpecifications.java @@ -1,4 +1,4 @@ -package hbp.mip.experiment; +package hbp.mip.analysis; import hbp.mip.utils.Exceptions.BadRequestException; import jakarta.persistence.criteria.*; @@ -9,16 +9,16 @@ import java.util.List; import java.util.Objects; -public class ExperimentSpecifications { - public static class ExperimentWithName implements Specification { +public class AnalysisSpecifications { + public static class AnalysisWithName implements Specification { private final String name; - public ExperimentWithName(String name) { + public AnalysisWithName(String name) { this.name = name; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { if (name == null) { return cb.isTrue(cb.literal(true)); @@ -29,34 +29,34 @@ public Predicate toPredicate(@NonNull Root root, @NonNull Criteri } } - public static class ExperimentWithAlgorithm implements Specification { + public static class AnalysisWithAlgorithm implements Specification { private final String algorithm; - public ExperimentWithAlgorithm(String algorithm) { + public AnalysisWithAlgorithm(String algorithm) { this.algorithm = algorithm; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { if (algorithm == null) { return cb.isTrue(cb.literal(true)); } - // The algorithm name lives in algorithm_id; "analysis" holds the whole analysis JSON. + // The algorithm name lives in algorithm_id; analysis_request holds the whole execution request JSON. return cb.equal(cb.lower(root.get("algorithmId")), this.algorithm.toLowerCase()); } } - public static class ExperimentWithViewed implements Specification { + public static class AnalysisWithViewed implements Specification { private final Boolean viewed; - public ExperimentWithViewed(Boolean viewed) { + public AnalysisWithViewed(Boolean viewed) { this.viewed = viewed; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery query, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery query, @NonNull CriteriaBuilder cb) { if (viewed == null) { return cb.isTrue(cb.literal(true)); // always true = no filtering @@ -65,15 +65,15 @@ public Predicate toPredicate(@NonNull Root root, @NonNull Criteri } } - public static class ExperimentWithShared implements Specification { + public static class AnalysisWithShared implements Specification { private final Boolean shared; - public ExperimentWithShared(Boolean shared) { + public AnalysisWithShared(Boolean shared) { this.shared = shared; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { if (shared == null) { return cb.isTrue(cb.literal(true)); @@ -82,51 +82,51 @@ public Predicate toPredicate(@NonNull Root root, @NonNull Criteri } } - public static class MyExperiment implements Specification { + public static class MyAnalysis implements Specification { private final String username; - public MyExperiment(String username) { + public MyAnalysis(String username) { this.username = username; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { if (username == null) { return cb.isTrue(cb.literal(true)); } - Join experimentDAOUserDAOJoin = root.join("createdBy"); - return cb.equal(experimentDAOUserDAOJoin.get("username"), username); + Join analysisDAOUserDAOJoin = root.join("createdBy"); + return cb.equal(analysisDAOUserDAOJoin.get("username"), username); } } - public static class NotMyExperiment implements Specification { + public static class NotMyAnalysis implements Specification { private final String username; - public NotMyExperiment(String username) { + public NotMyAnalysis(String username) { this.username = username; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { if (username == null) { return cb.isTrue(cb.literal(true)); } - Join experimentDAOUserDAOJoin = root.join("createdBy"); - return cb.notEqual(experimentDAOUserDAOJoin.get("username"), username); + Join analysisDAOUserDAOJoin = root.join("createdBy"); + return cb.notEqual(analysisDAOUserDAOJoin.get("username"), username); } } - public static class SharedExperiment implements Specification { + public static class SharedAnalysis implements Specification { private final boolean shared; - public SharedExperiment(boolean shared) { + public SharedAnalysis(boolean shared) { this.shared = shared; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { if (!shared) { return cb.isTrue(cb.literal(false)); @@ -135,8 +135,8 @@ public Predicate toPredicate(@NonNull Root root, @NonNull Criteri } } - /** Every dataset the experiment ran on is in {@code allowedDatasets}, a JSON array of lowercase codes. */ - public static class DatasetsReadable implements Specification { + /** Every dataset the analysis ran on is in {@code allowedDatasets}, a JSON array of lowercase codes. */ + public static class DatasetsReadable implements Specification { private final String allowedDatasets; @@ -144,20 +144,20 @@ public DatasetsReadable(String allowedDatasets) { this.allowedDatasets = allowedDatasets; } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { - // Defined in V5__ExperimentDatasetsReadableFunction.sql. - return cb.isTrue(cb.function("experiment_datasets_readable", Boolean.class, - root.get("analysis"), cb.literal(allowedDatasets))); + // Defined in V6__AnalysisStudyTerminology.sql. + return cb.isTrue(cb.function("analysis_datasets_readable", Boolean.class, + root.get("analysisRequest"), cb.literal(allowedDatasets))); } } - public static class ExperimentOrderBy implements Specification { + public static class AnalysisOrderBy implements Specification { private final String orderBy; private final Boolean descending; - public ExperimentOrderBy(String orderBy, Boolean descending) { + public AnalysisOrderBy(String orderBy, Boolean descending) { if (properColumnToBeOrderedBy(orderBy)) // Sorting "algorithm" means by the algorithm name stored in algorithm_id. this.orderBy = "algorithm".equals(orderBy) ? "algorithmId" : orderBy; @@ -166,7 +166,7 @@ public ExperimentOrderBy(String orderBy, Boolean descending) { this.descending = Objects.requireNonNullElse(descending, true); } - public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, + public Predicate toPredicate(@NonNull Root root, @NonNull CriteriaQuery criteriaQuery, @NonNull CriteriaBuilder cb) { if (descending) { criteriaQuery.orderBy(cb.desc(root.get(orderBy))); diff --git a/src/main/java/hbp/mip/analysis/SaveAnalysisRunDTO.java b/src/main/java/hbp/mip/analysis/SaveAnalysisRunDTO.java new file mode 100644 index 000000000..bf1d017c9 --- /dev/null +++ b/src/main/java/hbp/mip/analysis/SaveAnalysisRunDTO.java @@ -0,0 +1,4 @@ +package hbp.mip.analysis; + +public record SaveAnalysisRunDTO(String runId, String name) { +} diff --git a/src/main/java/hbp/mip/configurations/PersistenceConfiguration.java b/src/main/java/hbp/mip/configurations/PersistenceConfiguration.java index 22bda16d7..82d400eb4 100644 --- a/src/main/java/hbp/mip/configurations/PersistenceConfiguration.java +++ b/src/main/java/hbp/mip/configurations/PersistenceConfiguration.java @@ -18,7 +18,7 @@ import javax.sql.DataSource; @Configuration -@EnableJpaRepositories(basePackages = { "hbp.mip.experiment", "hbp.mip.user", "hbp.mip.folder" }) +@EnableJpaRepositories(basePackages = { "hbp.mip.analysis", "hbp.mip.user", "hbp.mip.study" }) @EnableTransactionManagement public class PersistenceConfiguration { @@ -36,7 +36,7 @@ public LocalContainerEntityManagerFactoryBean entityManagerFactory() { emfb.setDataSource(platformDataSource()); JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter(); emfb.setJpaVendorAdapter(vendorAdapter); - emfb.setPackagesToScan("hbp.mip.experiment", "hbp.mip.user", "hbp.mip.folder"); + emfb.setPackagesToScan("hbp.mip.analysis", "hbp.mip.user", "hbp.mip.study"); return emfb; } diff --git a/src/main/java/hbp/mip/datamodel/DataModelAPI.java b/src/main/java/hbp/mip/datamodel/DataModelAPI.java index c51cc9280..724267257 100644 --- a/src/main/java/hbp/mip/datamodel/DataModelAPI.java +++ b/src/main/java/hbp/mip/datamodel/DataModelAPI.java @@ -26,13 +26,13 @@ public DataModelAPI(ActiveUserService activeUserService, DataModelService dataMo @GetMapping public ResponseEntity> getDataModels(Authentication authentication) { - var logger = new Logger(activeUserService.getActiveUser(authentication).username(), "(GET) /dataModels"); - logger.info("Request for dataModels."); + var logger = new Logger(activeUserService.getActiveUser(authentication).username(), "(GET) /data-models"); + logger.info("Request for data models."); var dataModels = dataModelService.getDataModels(authentication, logger); String userDataModelsSTR = dataModels.stream().map(DataModelDTO::code) .collect(Collectors.joining(", ")); - logger.info("DataModels returned: " + dataModels.size() + ". [" + userDataModelsSTR + "]."); + logger.info("Data models returned: " + dataModels.size() + ". [" + userDataModelsSTR + "]."); return ResponseEntity.ok(dataModels); } diff --git a/src/main/java/hbp/mip/datamodel/DataModelService.java b/src/main/java/hbp/mip/datamodel/DataModelService.java index 920b54fc2..686a7c8fd 100644 --- a/src/main/java/hbp/mip/datamodel/DataModelService.java +++ b/src/main/java/hbp/mip/datamodel/DataModelService.java @@ -3,8 +3,8 @@ import com.google.gson.reflect.TypeToken; import hbp.mip.utils.ClaimUtils; import hbp.mip.utils.Exceptions.InternalServerError; -import hbp.mip.utils.Exceptions.NoAuthorizedPathologiesException; -import hbp.mip.utils.Exceptions.NoPathologiesAvailableException; +import hbp.mip.utils.Exceptions.NoAuthorizedDataModelsException; +import hbp.mip.utils.Exceptions.NoDataModelsAvailableException; import hbp.mip.utils.HTTPUtil; import hbp.mip.utils.JsonConverters; import hbp.mip.utils.Logger; @@ -44,8 +44,8 @@ public List getDataModels(Authentication authentication, Logger lo List allDataModelDTOS = getAggregatedDataModelDTOs(logger); if (allDataModelDTOS.isEmpty()) { - logger.warn("No pathologies are available for this federation."); - throw new NoPathologiesAvailableException("No pathologies are available for this federation."); + logger.warn("No data models are available for this federation."); + throw new NoDataModelsAvailableException("No data models are available for this federation."); } if (!authenticationIsEnabled) { @@ -56,9 +56,9 @@ public List getDataModels(Authentication authentication, Logger lo claimUtils.getAuthorizedDataModels(logger, authentication, allDataModelDTOS); if (authorizedDataModels.isEmpty()) { - logger.warn("User does not have access to any federation pathology."); - throw new NoAuthorizedPathologiesException( - "You do not have access to any of the pathologies in this federation." + logger.warn("User does not have access to any federation data model."); + throw new NoAuthorizedDataModelsException( + "You do not have access to any of the data models in this federation." ); } @@ -69,7 +69,7 @@ private List getAggregatedDataModelDTOs(Logger logger) { Map exaflowDataModelAttributes; Map>> datasetsVariablesByDataModel; Map> datasetEnumerationsByDataModel; - Type pathologyAttributesType = new TypeToken>(){}.getType(); + Type dataModelAttributesType = new TypeToken>(){}.getType(); Type datasetsVariablesType = new TypeToken>>>(){}.getType(); Type cdesMetadataType = new TypeToken>>(){}.getType(); @@ -77,7 +77,7 @@ private List getAggregatedDataModelDTOs(Logger logger) { StringBuilder response = new StringBuilder(); HTTPUtil.sendGet(exaflowAttributesUrl, exaflowApiToken, response); Map convertedResponse = - JsonConverters.convertJsonStringToObject(response.toString(), pathologyAttributesType); + JsonConverters.convertJsonStringToObject(response.toString(), dataModelAttributesType); exaflowDataModelAttributes = convertedResponse != null ? convertedResponse : Collections.emptyMap(); } catch (Exception e) { logger.error("Could not fetch exaflow dataModels' metadata: " + e.getMessage()); @@ -105,7 +105,7 @@ private List getAggregatedDataModelDTOs(Logger logger) { } List dataModelDTOs = new ArrayList<>(); - exaflowDataModelAttributes.forEach((pathology, attributes) -> { + exaflowDataModelAttributes.forEach((dataModelCode, attributes) -> { assert attributes.properties != null; assert attributes.properties.get("cdes") != null; assert !attributes.properties.get("cdes").isEmpty(); diff --git a/src/main/java/hbp/mip/experiment/ExperimentAPI.java b/src/main/java/hbp/mip/experiment/ExperimentAPI.java deleted file mode 100644 index 4b721efc7..000000000 --- a/src/main/java/hbp/mip/experiment/ExperimentAPI.java +++ /dev/null @@ -1,146 +0,0 @@ -package hbp.mip.experiment; - -import hbp.mip.user.ActiveUserService; -import hbp.mip.utils.JsonConverters; -import hbp.mip.utils.Logger; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; -import org.springframework.security.core.Authentication; -import org.springframework.web.bind.annotation.*; - -import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; - -@RestController -@RequestMapping(value = "/experiments", produces = { APPLICATION_JSON_VALUE }) -public class ExperimentAPI { - - private final ExperimentService experimentService; - private final ActiveUserService activeUserService; - - public ExperimentAPI( - ExperimentService experimentService, - ActiveUserService activeUserService) { - this.experimentService = experimentService; - this.activeUserService = activeUserService; - } - - @GetMapping - public ResponseEntity getExperiments(Authentication authentication, - @RequestParam(name = "name", required = false) String name, - @RequestParam(name = "algorithm", required = false) String algorithm, - @RequestParam(name = "shared", required = false) Boolean shared, - @RequestParam(name = "viewed", required = false) Boolean viewed, - @RequestParam(name = "includeShared", required = false, defaultValue = "true") boolean includeShared, - @RequestParam(name = "mine", required = false, defaultValue = "false") boolean mine, - @RequestParam(name = "notMine", required = false, defaultValue = "false") boolean notMine, - @RequestParam(name = "orderBy", required = false, defaultValue = "created") String orderBy, - @RequestParam(name = "descending", required = false, defaultValue = "true") Boolean descending, - @RequestParam(defaultValue = "0") int page, - @RequestParam(defaultValue = "10") int size) { - var logger = new Logger(activeUserService.getActiveUser(authentication).username(), "(GET) /experiments"); - logger.info( - "Request for experiments with parameters: " + - "name -> " + name + - " , algorithm -> " + algorithm + - " , shared -> " + shared + - " , viewed -> " + viewed + - " , includeShared -> " + includeShared + - " , mine -> " + mine + - " , notMine -> " + notMine + - " , orderBy -> " + orderBy + - " , descending -> " + descending + - " , page -> " + page + - " , size -> " + size); - var experimentsDTO = experimentService.getExperiments(authentication, - name, - algorithm, - shared, - viewed, - includeShared, - mine, - notMine, - page, - size, - orderBy, - descending, - logger); - logger.info("Experiments returned: " + experimentsDTO.experiments().size()); - return new ResponseEntity<>(experimentsDTO, HttpStatus.OK); - } - - @GetMapping(value = "/{uuid}") - public ResponseEntity getExperiment(Authentication authentication, - @PathVariable("uuid") String uuid) { - var logger = new Logger(activeUserService.getActiveUser(authentication).username(), - "(GET) /experiments/" + uuid); - logger.info("Request for experiment with id: " + uuid); - var experimentResponse = experimentService.getExperiment(authentication, uuid, logger); - logger.info("Experiment returned."); - return new ResponseEntity<>(experimentResponse, HttpStatus.OK); - } - - @PostMapping - public ResponseEntity saveExperimentRun(Authentication authentication, - @RequestBody SaveExperimentRunDTO saveExperimentRunDTO) { - var user = activeUserService.getActiveUser(authentication); - var logger = new Logger(user.username(), "(POST) /experiments"); - logger.info("Request to save experiment run with id: " + saveExperimentRunDTO.runId()); - var experimentResponse = experimentService.saveExperimentRun(user, saveExperimentRunDTO.runId(), - saveExperimentRunDTO.name(), logger); - logger.info("Experiment run saved. Run id: " + saveExperimentRunDTO.runId() + ", experiment id: " - + experimentResponse.uuid()); - return new ResponseEntity<>(experimentResponse, HttpStatus.CREATED); - } - - @PatchMapping(value = "/{uuid}") - public ResponseEntity updateExperiment(Authentication authentication, - @RequestBody ExperimentDTO experimentRequest, @PathVariable("uuid") String uuid) { - var user = activeUserService.getActiveUser(authentication); - var logger = new Logger(user.username(), "(PATCH) /experiments/" + uuid); - logger.info("Request for experiment update with id: " + uuid + ". Request Body: " - + JsonConverters.convertObjectToJsonString(experimentRequest)); - var experimentResponse = experimentService.updateExperiment(user, uuid, experimentRequest, logger); - logger.info("Experiment updated. Id: " + uuid); - return new ResponseEntity<>(experimentResponse, HttpStatus.OK); - } - - @RequestMapping(value = "/{uuid}", method = RequestMethod.DELETE) - public ResponseEntity deleteExperiment(Authentication authentication, @PathVariable("uuid") String uuid) { - var user = activeUserService.getActiveUser(authentication); - var logger = new Logger(user.username(), "(DELETE) /experiments/" + uuid); - logger.info("Request for experiment deletion with id: " + uuid); - experimentService.deleteExperiment(user, uuid, logger); - logger.info("Experiment deleted. Id: " + uuid); - return new ResponseEntity<>(HttpStatus.OK); - } - - @PostMapping(value = "/preview") - public ResponseEntity previewExperiment(Authentication authentication, - @RequestBody ExperimentExecutionDTO experimentExecutionDTO) { - var logger = new Logger(activeUserService.getActiveUser(authentication).username(), - "(POST) /experiments/preview"); - logger.debug("Request for experiment preview. RequestBody: " - + JsonConverters.convertObjectToJsonString(experimentExecutionDTO)); - - var experimentResponse = experimentService.previewExperiment(authentication, experimentExecutionDTO, logger); - - logger.info("Experiment preview finished. Status: " + experimentResponse.status()); - return new ResponseEntity<>(experimentResponse, HttpStatus.OK); - } - - @PostMapping(value = "/runs") - public ResponseEntity runExperiment(Authentication authentication, - @RequestBody ExperimentExecutionDTO experimentExecutionDTO) { - var user = activeUserService.getActiveUser(authentication); - var logger = new Logger(user.username(), "(POST) /experiments/runs"); - logger.debug("Request for experiment run. RequestBody: " - + JsonConverters.convertObjectToJsonString(experimentExecutionDTO)); - - var experimentResponse = experimentService.runExperiment(authentication, user, experimentExecutionDTO, - logger); - - logger.info("Experiment run finished. Id: " + experimentResponse.uuid() - + " Status: " + experimentResponse.status()); - return new ResponseEntity<>(experimentResponse, HttpStatus.OK); - } -} diff --git a/src/main/java/hbp/mip/experiment/ExperimentDTO.java b/src/main/java/hbp/mip/experiment/ExperimentDTO.java deleted file mode 100644 index 02abec6f0..000000000 --- a/src/main/java/hbp/mip/experiment/ExperimentDTO.java +++ /dev/null @@ -1,38 +0,0 @@ -package hbp.mip.experiment; - -import hbp.mip.algorithm.AnalysisRequestDTO; -import hbp.mip.user.UserDTO; -import hbp.mip.utils.RawJson; - -import java.util.Date; -import java.util.UUID; - -public record ExperimentDTO( - UUID uuid, - String name, - UserDTO createdBy, - Date created, - Date updated, - Date finished, - Boolean shared, - Boolean viewed, - Object result, - ExperimentDAO.Status status, - AnalysisRequestDTO analysis, - String mipVersion) { - public ExperimentDTO(ExperimentDAO experimentDAO, boolean includeResult) { - this( - experimentDAO.getUuid(), - experimentDAO.getName(), - new UserDTO(experimentDAO.getCreatedBy()), - experimentDAO.getCreated(), - experimentDAO.getUpdated(), - experimentDAO.getFinished(), - experimentDAO.isShared(), - experimentDAO.isViewed(), - includeResult && experimentDAO.getResult() != null ? new RawJson(experimentDAO.getResult()) : null, - experimentDAO.getStatus(), - AnalysisRequestDTO.fromStored(experimentDAO.getAnalysis()), - experimentDAO.getMipVersion()); - } -} diff --git a/src/main/java/hbp/mip/experiment/ExperimentExecutionDTO.java b/src/main/java/hbp/mip/experiment/ExperimentExecutionDTO.java deleted file mode 100644 index 77a01db60..000000000 --- a/src/main/java/hbp/mip/experiment/ExperimentExecutionDTO.java +++ /dev/null @@ -1,8 +0,0 @@ -package hbp.mip.experiment; - -import hbp.mip.algorithm.AnalysisRequestDTO; - -public record ExperimentExecutionDTO( - String name, - AnalysisRequestDTO analysis) { -} diff --git a/src/main/java/hbp/mip/experiment/ExperimentRepository.java b/src/main/java/hbp/mip/experiment/ExperimentRepository.java deleted file mode 100644 index 0256508c8..000000000 --- a/src/main/java/hbp/mip/experiment/ExperimentRepository.java +++ /dev/null @@ -1,67 +0,0 @@ -package hbp.mip.experiment; - -import hbp.mip.user.UserDAO; -import hbp.mip.user.UserDTO; -import hbp.mip.utils.Exceptions.BadRequestException; -import hbp.mip.utils.Exceptions.ExperimentNotFoundException; -import hbp.mip.utils.Logger; -import org.springframework.data.jpa.repository.JpaSpecificationExecutor; -import org.springframework.data.repository.CrudRepository; - -import java.util.UUID; - -public interface ExperimentRepository - extends CrudRepository, JpaSpecificationExecutor { - ExperimentDAO findByUuid(UUID experimentUuid); - - static UUID parseUuid(String uuid, Logger logger) { - try { - return UUID.fromString(uuid); - } catch (IllegalArgumentException e) { - logger.error("Conversion of string to UUID failed:" + e.getMessage()); - throw new BadRequestException(e.getMessage()); - } - } - - default ExperimentDAO loadExperiment(String uuid, Logger logger) { - UUID experimentUuid = parseUuid(uuid, logger); - - ExperimentDAO experimentDAO = findByUuid(experimentUuid); - if (experimentDAO == null) { - var errorMessage = "Experiment with uuid : " + uuid + "was not found."; - logger.warn(errorMessage); - throw new ExperimentNotFoundException(errorMessage); - } - - return experimentDAO; - } - - /** - * Persists a kept run as a finished experiment. Everything describing the run (analysis, result, - * when it started and finished, which MIP version computed it) is copied unchanged; only the - * identity, owner and name are new, so one run can be saved more than once. - */ - default ExperimentDAO createExperimentFromRun(ExperimentRunDAO run, String name, UserDTO user, - Logger logger) { - ExperimentDAO experimentDAO = new ExperimentDAO(); - - experimentDAO.setUuid(UUID.randomUUID()); - experimentDAO.setCreatedBy(new UserDAO(user)); - experimentDAO.setAnalysis(run.getAnalysis()); - experimentDAO.setAlgorithmId(run.getAlgorithmId()); - experimentDAO.setName(name); - experimentDAO.setMipVersion(run.getMipVersion()); - experimentDAO.setStatus(ExperimentDAO.Status.success); - experimentDAO.setResult(run.getResult()); - experimentDAO.setCreated(run.getCreated()); - experimentDAO.setFinished(run.getFinished()); - - try { - save(experimentDAO); - } catch (Exception e) { - logger.error("Failed to save to the database: " + e.getMessage()); - throw e; - } - return experimentDAO; - } -} diff --git a/src/main/java/hbp/mip/experiment/ExperimentService.java b/src/main/java/hbp/mip/experiment/ExperimentService.java deleted file mode 100644 index f3f733931..000000000 --- a/src/main/java/hbp/mip/experiment/ExperimentService.java +++ /dev/null @@ -1,386 +0,0 @@ -package hbp.mip.experiment; - -import hbp.mip.algorithm.AnalysisRequestDTO; -import hbp.mip.algorithm.AnalysisService; -import hbp.mip.user.ActiveUserService; -import hbp.mip.user.UserDTO; -import hbp.mip.utils.*; -import hbp.mip.utils.Exceptions.*; -import org.springframework.beans.factory.annotation.Value; -import org.springframework.data.domain.*; -import org.springframework.data.jpa.domain.Specification; -import org.springframework.security.core.Authentication; -import org.springframework.stereotype.Service; - -import java.time.Duration; -import java.util.*; - -import static hbp.mip.utils.JsonConverters.convertObjectToJsonString; - -@Service -public class ExperimentService { - - private static final int MAX_PAGE_SIZE = 50; - - private final ActiveUserService activeUserService; - private final ClaimUtils claimUtils; - private final ExperimentRepository experimentRepository; - private final ExperimentRunRepository experimentRunRepository; - private final AnalysisService analysisService; - private final boolean authenticationIsEnabled; - private final String mipVersion; - private final Duration runDraftTtl; - - public ExperimentService( - ActiveUserService activeUserService, - ClaimUtils claimUtils, - ExperimentRepository experimentRepository, - ExperimentRunRepository experimentRunRepository, - AnalysisService analysisService, - @Value("${authentication.enabled}") boolean authenticationIsEnabled, - @Value("${mip.version}") String mipVersion, - @Value("${experiments.run-draft-ttl}") Duration runDraftTtl) { - this.activeUserService = activeUserService; - this.claimUtils = claimUtils; - this.experimentRepository = experimentRepository; - this.experimentRunRepository = experimentRunRepository; - this.analysisService = analysisService; - this.authenticationIsEnabled = authenticationIsEnabled; - this.mipVersion = mipVersion; - this.runDraftTtl = runDraftTtl; - } - - public ExperimentsDTO getExperiments(Authentication authentication, String name, String algorithm, Boolean shared, - Boolean viewed, boolean includeShared, boolean mine, boolean notMine, int page, int size, String orderBy, - Boolean descending, - Logger logger) { - validatePageSize(size); - - Specification spec = buildExperimentSpecification(authentication, name, algorithm, shared, - viewed, includeShared, mine, notMine, orderBy, descending, logger); - Pageable pageable = PageRequest.of(page, size); - Page experimentsPage = experimentRepository.findAll(spec, pageable); - - if (experimentsPage.isEmpty()) { - throw new NoContent("No experiment found with the filters provided."); - } - - return createExperimentsDTO(experimentsPage); - } - - private void validatePageSize(int size) { - if (size > MAX_PAGE_SIZE) { - throw new BadRequestException("Invalid size input, max size is " + MAX_PAGE_SIZE); - } - } - - private Specification buildExperimentSpecification(Authentication authentication, String name, - String algorithm, Boolean shared, Boolean viewed, boolean includeShared, boolean mine, boolean notMine, - String orderBy, - Boolean descending, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - boolean hasAccessRights = !authenticationIsEnabled - || claimUtils.validateAccessRightsOnALLExperiments(authentication, logger); - - Specification spec; - - if (mine) { - spec = Specification.where(new ExperimentSpecifications.MyExperiment(user.username())); - } else if (notMine) { - spec = Specification.where(new ExperimentSpecifications.NotMyExperiment(user.username())) - .and(sharedAndReadable(authentication, true, hasAccessRights, logger)); - } else if (hasAccessRights) { - spec = (root, query, criteriaBuilder) -> criteriaBuilder.conjunction(); - } else { - spec = Specification.where(new ExperimentSpecifications.MyExperiment(user.username())) - .or(sharedAndReadable(authentication, includeShared, hasAccessRights, logger)); - } - - return spec - .and(new ExperimentSpecifications.ExperimentWithName(name)) - .and(new ExperimentSpecifications.ExperimentWithAlgorithm(algorithm)) - .and(new ExperimentSpecifications.ExperimentWithShared(shared)) - .and(new ExperimentSpecifications.ExperimentWithViewed(viewed)) - .and(new ExperimentSpecifications.ExperimentOrderBy(orderBy, descending)); - } - - // canRead's rule for lists, in the query: filtering afterwards would let totals and filters reveal hidden experiments. - private Specification sharedAndReadable(Authentication authentication, boolean shared, - boolean hasAccessRights, Logger logger) { - Specification spec = new ExperimentSpecifications.SharedExperiment(shared); - List datasets = hasAccessRights ? null : claimUtils.usableDatasets(authentication, logger); - return datasets == null - ? spec - : spec.and(new ExperimentSpecifications.DatasetsReadable(convertObjectToJsonString(datasets))); - } - - private ExperimentsDTO createExperimentsDTO(Page pageExperiments) { - List experiments = pageExperiments.map(experimentDAO -> new ExperimentDTO(experimentDAO, false)) - .getContent(); - return new ExperimentsDTO(experiments, pageExperiments.getNumber(), pageExperiments.getTotalPages(), - pageExperiments.getTotalElements()); - } - - public ExperimentDTO getExperiment(Authentication authentication, String uuid, Logger logger) { - ExperimentDAO experimentDAO = assertExperimentAccessible(authentication, uuid, logger); - - return new ExperimentDTO(experimentDAO, true); - } - - /** - * Loads an experiment and refuses it when the active user may not read it, returning the entity so - * other features can reference a run they are allowed to see. - * - * Feature code that only needs to know "is this run usable by this user" should call this instead - * of reopening the access rules, which live in one place on purpose. - */ - public ExperimentDAO assertExperimentAccessible(Authentication authentication, String uuid, Logger logger) { - ExperimentDAO experimentDAO = experimentRepository.loadExperiment(uuid, logger); - validateExperimentAccess(authentication, experimentDAO, uuid, logger); - - return experimentDAO; - } - - private void validateExperimentAccess(Authentication authentication, ExperimentDAO experimentDAO, String uuid, - Logger logger) { - var user = activeUserService.getActiveUser(authentication); - - if (!canRead(authentication, user, experimentDAO, logger)) { - logger.warn("User tried to access an unauthorized experiment with id:" + uuid); - throw new UnauthorizedException("You don't have access to that experiment."); - } - } - - /** Sharing an experiment does not open its data: others also need the datasets it ran on. */ - private boolean canRead(Authentication authentication, UserDTO user, ExperimentDAO experimentDAO, Logger logger) { - if (!authenticationIsEnabled - || experimentDAO.getCreatedBy().getUsername().equals(user.username()) - || claimUtils.validateAccessRightsOnALLExperiments(authentication, logger)) { - return true; - } - return experimentDAO.isShared() - && claimUtils.hasAccessRightsOnDatasets(authentication, datasetsOf(experimentDAO), logger); - } - - private static List datasetsOf(ExperimentDAO experimentDAO) { - AnalysisRequestDTO analysis = AnalysisRequestDTO.fromStored(experimentDAO.getAnalysis()); - return analysis != null && analysis.inputdata() != null ? analysis.inputdata().allDatasets() : null; - } - - private void validateDatasetAccess(Authentication authentication, AnalysisRequestDTO analysis, Logger logger) { - if (authenticationIsEnabled) { - claimUtils.validateAccessRightsOnDatasets(authentication, analysis.inputdata().allDatasets(), logger); - } - } - - /** Runs an analysis and returns its result without storing anything. */ - public ExperimentDTO previewExperiment(Authentication authentication, - ExperimentExecutionDTO experimentExecutionDTO, Logger logger) { - AnalysisService.requireRunnable(experimentExecutionDTO.analysis(), logger); - analysisParametersLogging(experimentExecutionDTO, logger); - - validateDatasetAccess(authentication, experimentExecutionDTO.analysis(), logger); - UUID uuid = UUID.randomUUID(); - AnalysisService.AnalysisResultDTO analysisResult = analysisService.runAnalysis( - uuid, - experimentExecutionDTO.analysis(), - logger); - - return new ExperimentDTO(uuid, experimentExecutionDTO.name(), null, null, null, null, null, null, - analysisResult.body(), - analysisResult.code() >= 400 ? ExperimentDAO.Status.error : ExperimentDAO.Status.success, - experimentExecutionDTO.analysis(), - mipVersion); - } - - /** - * Runs an analysis like {@link #previewExperiment} and, when it succeeds, keeps the result so - * {@link #saveExperimentRun} can persist it later without executing the analysis again. The - * returned uuid is the run id to save. - */ - public ExperimentDTO runExperiment(Authentication authentication, UserDTO user, - ExperimentExecutionDTO experimentExecutionDTO, Logger logger) { - Date started = new Date(); - ExperimentDTO run = previewExperiment(authentication, experimentExecutionDTO, logger); - if (run.status() == ExperimentDAO.Status.success) { - keepRun(run, experimentExecutionDTO.analysis(), started, user, logger); - } - return run; - } - - private void keepRun(ExperimentDTO run, AnalysisRequestDTO analysis, Date started, UserDTO user, - Logger logger) { - ExperimentRunDAO runDAO = new ExperimentRunDAO(); - runDAO.setUuid(run.uuid()); - runDAO.setCreatedByUsername(user.username()); - runDAO.setAnalysis(convertObjectToJsonString(analysis)); - runDAO.setAlgorithmId(analysis.algorithm().name()); - runDAO.setResult(convertObjectToJsonString(run.result())); - runDAO.setCreated(started); - runDAO.setFinished(new Date()); - runDAO.setMipVersion(mipVersion); - - // Purging is housekeeping; a failure here must not stop this run from being kept. - try { - experimentRunRepository.deleteCreatedBefore(runDraftCutoff()); - } catch (Exception e) { - logger.warn("Failed to purge expired runs: " + e.getMessage()); - } - - // The result is still returned when it cannot be kept; saving it later then reports it as missing. - try { - experimentRunRepository.save(runDAO); - } catch (Exception e) { - logger.error("Failed to keep the run in the database: " + e.getMessage()); - } - } - - /** - * Persists a run kept by {@link #runExperiment} as an experiment of the active user. The stored - * analysis and result are the ones the run produced; nothing is sent to Exaflow. - */ - public ExperimentDTO saveExperimentRun(UserDTO user, String runId, String name, Logger logger) { - if (name == null || name.isBlank()) { - throw new BadRequestException("An experiment name is required."); - } - if (runId == null || runId.isBlank()) { - throw new BadRequestException("A runId is required."); - } - - // Dataset access was validated when the run executed; the kept run is owner-only, so it is not checked again. - ExperimentRunDAO run = loadKeptRun(runId, user, logger); - - ExperimentDAO experimentDAO = experimentRepository.createExperimentFromRun(run, name.trim(), user, logger); - return new ExperimentDTO(experimentDAO, false); - } - - private ExperimentRunDAO loadKeptRun(String runId, UserDTO user, Logger logger) { - // Another user's run reads as missing, so run ids cannot be probed. - return experimentRunRepository.findById(ExperimentRepository.parseUuid(runId, logger)) - .filter(run -> run.getCreatedByUsername().equals(user.username())) - .filter(run -> !run.getCreated().before(runDraftCutoff())) - .orElseThrow(() -> { - logger.warn("Run to save was not found or has expired. Id: " + runId); - return new ExperimentNotFoundException( - "This run is no longer available to save. Run the experiment again."); - }); - } - - private Date runDraftCutoff() { - return new Date(System.currentTimeMillis() - runDraftTtl.toMillis()); - } - - public ExperimentDTO updateExperiment(UserDTO user, String uuid, ExperimentDTO experiment, Logger logger) { - ExperimentDAO experimentDAO = experimentRepository.loadExperiment(uuid, logger); - - verifyNonEditableFieldsAreNotBeingModified(experiment, logger); - checkUpdateAuthorization(user, experimentDAO, uuid, logger); - - updateModifiableFields(experiment, experimentDAO); - experimentDAO.setUpdated(new Date()); - - try { - experimentRepository.save(experimentDAO); - } catch (Exception e) { - logger.error("Failed to save to the database: " + e.getMessage()); - throw new InternalServerError(e.getMessage()); - } - - return new ExperimentDTO(experimentDAO, true); - } - - private void checkUpdateAuthorization(UserDTO user, ExperimentDAO experimentDAO, String uuid, Logger logger) { - if (!experimentDAO.getCreatedBy().getUsername().equals(user.username())) { - logger.warn("User tried to modify an unauthorized experiment with uuid: " + uuid); - throw new UnauthorizedException("You don't have access to modify the experiment."); - } - } - - private void updateModifiableFields(ExperimentDTO experiment, ExperimentDAO experimentDAO) { - if (experiment.name() != null && !experiment.name().isEmpty()) { - experimentDAO.setName(experiment.name()); - } - if (experiment.shared() != null) { - experimentDAO.setShared(experiment.shared()); - } - if (experiment.viewed() != null) { - experimentDAO.setViewed(experiment.viewed()); - } - } - - public void deleteExperiment(UserDTO user, String uuid, Logger logger) { - ExperimentDAO experimentDAO = experimentRepository.loadExperiment(uuid, logger); - - checkDeleteAuthorization(user, experimentDAO, uuid, logger); - - try { - experimentRepository.delete(experimentDAO); - } catch (Exception e) { - logger.info("Attempted to delete an experiment from the database but an error occurred: " + e.getMessage()); - throw new InternalServerError(e.getMessage()); - } - } - - private void checkDeleteAuthorization(UserDTO user, ExperimentDAO experimentDAO, String uuid, Logger logger) { - if (!experimentDAO.getCreatedBy().getUsername().equals(user.username())) { - logger.warn("User " + user.username() + " tried to delete the experiment with uuid " + uuid - + " but was unauthorized."); - throw new UnauthorizedException("You don't have access to delete the experiment."); - } - } - - private void verifyNonEditableFieldsAreNotBeingModified(ExperimentDTO experimentDTO, Logger logger) { - throwIfNonNull(experimentDTO.uuid(), "uuid", logger); - throwIfNonNull(experimentDTO.createdBy(), "createdBy", logger); - throwIfNonNull(experimentDTO.created(), "created", logger); - throwIfNonNull(experimentDTO.updated(), "updated", logger); - throwIfNonNull(experimentDTO.finished(), "finished", logger); - throwIfNonNull(experimentDTO.result(), "result", logger); - throwIfNonNull(experimentDTO.status(), "status", logger); - throwIfNonNull(experimentDTO.analysis(), "analysis", logger); - } - - private void throwIfNonNull(Object field, String nonEditableField, Logger logger) { - if (field != null) { - String errorMessage = "Tried to edit non-editable field: " + nonEditableField; - logger.warn(errorMessage); - throw new BadRequestException(errorMessage); - } - } - - private void analysisParametersLogging(ExperimentExecutionDTO experimentExecutionDTO, Logger logger) { - AnalysisRequestDTO analysis = experimentExecutionDTO.analysis(); - StringBuilder parametersLogMessage = new StringBuilder(); - - Optional.ofNullable(analysis.algorithm().parameters()).ifPresent(parameters -> parameters.forEach((paramName, - paramValue) -> parametersLogMessage.append(" ").append(paramName).append(" -> ").append(paramValue))); - - Optional.ofNullable(analysis.preprocessing()).ifPresent(preprocessing -> preprocessing - .forEach(step -> parametersLogMessage.append(" ").append(step.name()).append(" -> ") - .append(step.parameters()))); - - if (analysis.inputdata() != null) { - AnalysisRequestDTO.AnalysisInputDataDTO inputData = analysis.inputdata(); - parametersLogMessage.append(" Input Data Model: ").append(inputData.data_model()); - - Optional.ofNullable(inputData.datasets()) - .ifPresent(datasets -> parametersLogMessage.append(" Datasets: ").append(datasets)); - - Optional.ofNullable(inputData.variables()) - .ifPresent(variables -> parametersLogMessage.append(" Variables: ").append(variables)); - - Optional.ofNullable(analysis.algorithm().x()) - .ifPresent(xVars -> parametersLogMessage.append(" X Variables: ").append(xVars)); - - Optional.ofNullable(analysis.algorithm().y()) - .ifPresent(yVars -> parametersLogMessage.append(" Y Variables: ").append(yVars)); - - if (inputData.filters() != null) { - parametersLogMessage.append(" Filters: ").append(inputData.filters()); - } - } - - logger.debug("Analysis " + analysis.algorithm().name() + " execution starting with parameters: " - + parametersLogMessage); - } -} diff --git a/src/main/java/hbp/mip/experiment/ExperimentsDTO.java b/src/main/java/hbp/mip/experiment/ExperimentsDTO.java deleted file mode 100644 index a23fbece1..000000000 --- a/src/main/java/hbp/mip/experiment/ExperimentsDTO.java +++ /dev/null @@ -1,11 +0,0 @@ -package hbp.mip.experiment; - -import java.util.List; - -public record ExperimentsDTO( - List experiments, - Integer currentPage, - Integer totalPages, - Long totalExperiments -) { -} diff --git a/src/main/java/hbp/mip/experiment/SaveExperimentRunDTO.java b/src/main/java/hbp/mip/experiment/SaveExperimentRunDTO.java deleted file mode 100644 index bd2e03b79..000000000 --- a/src/main/java/hbp/mip/experiment/SaveExperimentRunDTO.java +++ /dev/null @@ -1,4 +0,0 @@ -package hbp.mip.experiment; - -public record SaveExperimentRunDTO(String runId, String name) { -} diff --git a/src/main/java/hbp/mip/folder/AddExperimentFoldersMemberDTO.java b/src/main/java/hbp/mip/folder/AddExperimentFoldersMemberDTO.java deleted file mode 100644 index dcd063adb..000000000 --- a/src/main/java/hbp/mip/folder/AddExperimentFoldersMemberDTO.java +++ /dev/null @@ -1,5 +0,0 @@ -package hbp.mip.folder; - -/** Request body of "add a run to a folder". Re-adding an existing member is a no-op, not an error. */ -public record AddExperimentFoldersMemberDTO(String experimentUuid) { -} diff --git a/src/main/java/hbp/mip/folder/CreateExperimentGroupDTO.java b/src/main/java/hbp/mip/folder/CreateExperimentGroupDTO.java deleted file mode 100644 index eac458aae..000000000 --- a/src/main/java/hbp/mip/folder/CreateExperimentGroupDTO.java +++ /dev/null @@ -1,10 +0,0 @@ -package hbp.mip.folder; - -/** - * Request body of "create folder" and "create set". The id and the order are assigned by the service. - * - * The experiment is optional: "put this run in a new folder/set" is one gesture in the row menu, and one - * request means a failed second call can never leave an empty folder or set behind. - */ -public record CreateExperimentGroupDTO(String name, String experimentUuid) { -} diff --git a/src/main/java/hbp/mip/folder/ExperimentFolderAPI.java b/src/main/java/hbp/mip/folder/ExperimentFolderAPI.java deleted file mode 100644 index c190f317d..000000000 --- a/src/main/java/hbp/mip/folder/ExperimentFolderAPI.java +++ /dev/null @@ -1,181 +0,0 @@ -package hbp.mip.folder; - -import hbp.mip.user.ActiveUserService; -import hbp.mip.utils.JsonConverters; -import hbp.mip.utils.Logger; -import org.springframework.http.HttpStatus; -import org.springframework.http.ResponseEntity; -import org.springframework.security.core.Authentication; -import org.springframework.web.bind.annotation.DeleteMapping; -import org.springframework.web.bind.annotation.GetMapping; -import org.springframework.web.bind.annotation.PatchMapping; -import org.springframework.web.bind.annotation.PathVariable; -import org.springframework.web.bind.annotation.PostMapping; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RestController; - -import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; - -/** - * Folders ("analysis sets") and the sets inside them, for the active user only. - * - * Routes sit under the /services servlet context, so the public paths are - * /services/experiment-folders/.... - * - * Statuses: 200 for reads and for every mutation that leaves a folder behind — the updated folder is - * the body, so the caller never has to guess at ordering or partitioning — 201 for a new folder or set, - * 204 only when the folder itself is gone, 400 for a blank or malformed name/id, 404 when the folder or - * set is not the caller's, 409 for a duplicate name, 401 when the run cannot be read. - */ -@RestController -@RequestMapping(value = "/experiment-folders", produces = { APPLICATION_JSON_VALUE }) -public class ExperimentFolderAPI { - - private final ExperimentFolderService experimentFolderService; - private final ActiveUserService activeUserService; - - public ExperimentFolderAPI(ExperimentFolderService experimentFolderService, - ActiveUserService activeUserService) { - this.experimentFolderService = experimentFolderService; - this.activeUserService = activeUserService; - } - - @GetMapping - public ResponseEntity getFolders(Authentication authentication) { - var logger = logger(authentication, "(GET) /experiment-folders"); - logger.info("Request for the experiment folders of the active user."); - var folders = experimentFolderService.getFolders(authentication, logger); - logger.info("Experiment folders returned: " + folders.folders().size()); - return new ResponseEntity<>(folders, HttpStatus.OK); - } - - @PostMapping - public ResponseEntity createFolder(Authentication authentication, - @RequestBody CreateExperimentGroupDTO createExperimentGroupDTO) { - var logger = logger(authentication, "(POST) /experiment-folders"); - logger.debug("Request for experiment folder creation. RequestBody: " - + JsonConverters.convertObjectToJsonString(createExperimentGroupDTO)); - var folder = experimentFolderService.createFolder(authentication, createExperimentGroupDTO, logger); - logger.info("Experiment folder created with id: " + folder.id()); - return new ResponseEntity<>(folder, HttpStatus.CREATED); - } - - @GetMapping(value = "/{folderId}") - public ResponseEntity getFolder(Authentication authentication, - @PathVariable("folderId") String folderId) { - var logger = logger(authentication, "(GET) /experiment-folders/" + folderId); - logger.info("Request for experiment folder with id: " + folderId); - var folder = experimentFolderService.getFolder(authentication, folderId, logger); - logger.info("Experiment folder returned."); - return new ResponseEntity<>(folder, HttpStatus.OK); - } - - @PatchMapping(value = "/{folderId}") - public ResponseEntity renameFolder(Authentication authentication, - @PathVariable("folderId") String folderId, - @RequestBody RenameExperimentGroupDTO renameExperimentGroupDTO) { - var logger = logger(authentication, "(PATCH) /experiment-folders/" + folderId); - logger.debug("Request for experiment folder rename. RequestBody: " - + JsonConverters.convertObjectToJsonString(renameExperimentGroupDTO)); - var folder = experimentFolderService.renameFolder(authentication, folderId, renameExperimentGroupDTO, logger); - logger.info("Experiment folder renamed. Id: " + folderId); - return new ResponseEntity<>(folder, HttpStatus.OK); - } - - @DeleteMapping(value = "/{folderId}") - public ResponseEntity deleteFolder(Authentication authentication, - @PathVariable("folderId") String folderId) { - var logger = logger(authentication, "(DELETE) /experiment-folders/" + folderId); - logger.info("Request for experiment folder deletion with id: " + folderId); - experimentFolderService.deleteFolder(authentication, folderId, logger); - logger.info("Experiment folder deleted. Id: " + folderId); - return new ResponseEntity<>(HttpStatus.NO_CONTENT); - } - - /** Adding a run the folder already holds answers 200 with the folder, not 409. */ - @PostMapping(value = "/{folderId}/members") - public ResponseEntity addExperiment(Authentication authentication, - @PathVariable("folderId") String folderId, - @RequestBody AddExperimentFoldersMemberDTO addExperimentFoldersMemberDTO) { - var logger = logger(authentication, "(POST) /experiment-folders/" + folderId + "/members"); - logger.debug("Request for experiment addition to a folder. RequestBody: " - + JsonConverters.convertObjectToJsonString(addExperimentFoldersMemberDTO)); - var folder = experimentFolderService.addExperiment(authentication, folderId, addExperimentFoldersMemberDTO, - logger); - logger.info("Experiment added to the folder."); - return new ResponseEntity<>(folder, HttpStatus.OK); - } - - /** Answers with the folder rather than 204: losing a member changes the member list and a set. */ - @DeleteMapping(value = "/{folderId}/members/{experimentUuid}") - public ResponseEntity removeExperiment(Authentication authentication, - @PathVariable("folderId") String folderId, - @PathVariable("experimentUuid") String experimentUuid) { - var logger = logger(authentication, "(DELETE) /experiment-folders/" + folderId + "/members/" + experimentUuid); - logger.info("Request to remove experiment " + experimentUuid + " from folder " + folderId); - var folder = experimentFolderService.removeExperiment(authentication, folderId, experimentUuid, logger); - logger.info("Experiment removed from the folder."); - return new ResponseEntity<>(folder, HttpStatus.OK); - } - - @PostMapping(value = "/{folderId}/sets") - public ResponseEntity createSet(Authentication authentication, - @PathVariable("folderId") String folderId, - @RequestBody CreateExperimentGroupDTO createExperimentGroupDTO) { - var logger = logger(authentication, "(POST) /experiment-folders/" + folderId + "/sets"); - logger.debug("Request for experiment set creation. RequestBody: " - + JsonConverters.convertObjectToJsonString(createExperimentGroupDTO)); - var folder = experimentFolderService.createSet(authentication, folderId, createExperimentGroupDTO, logger); - logger.info("Experiment set created in folder: " + folderId); - return new ResponseEntity<>(folder, HttpStatus.CREATED); - } - - @PatchMapping(value = "/{folderId}/sets/{setId}") - public ResponseEntity renameSet(Authentication authentication, - @PathVariable("folderId") String folderId, - @PathVariable("setId") String setId, - @RequestBody RenameExperimentGroupDTO renameExperimentGroupDTO) { - var logger = logger(authentication, "(PATCH) /experiment-folders/" + folderId + "/sets/" + setId); - logger.debug("Request for experiment set rename. RequestBody: " - + JsonConverters.convertObjectToJsonString(renameExperimentGroupDTO)); - var folder = experimentFolderService.renameSet(authentication, folderId, setId, renameExperimentGroupDTO, logger); - logger.info("Experiment set renamed. Id: " + setId); - return new ResponseEntity<>(folder, HttpStatus.OK); - } - - /** Answers with the folder rather than 204: the retired set moved its runs into Ungrouped. */ - @DeleteMapping(value = "/{folderId}/sets/{setId}") - public ResponseEntity deleteSet(Authentication authentication, - @PathVariable("folderId") String folderId, - @PathVariable("setId") String setId) { - var logger = logger(authentication, "(DELETE) /experiment-folders/" + folderId + "/sets/" + setId); - logger.info("Request for experiment set deletion with id: " + setId); - var folder = experimentFolderService.deleteSet(authentication, folderId, setId, logger); - logger.info("Experiment set deleted. Its runs were left in the folder, ungrouped."); - return new ResponseEntity<>(folder, HttpStatus.OK); - } - - /** - * Moves a run into a set — or, with a null setId, out of its set and back to ungrouped. The run - * stays in the folder either way. - */ - @PatchMapping(value = "/{folderId}/members/{experimentUuid}/set") - public ResponseEntity updateSetMembership(Authentication authentication, - @PathVariable("folderId") String folderId, - @PathVariable("experimentUuid") String experimentUuid, - @RequestBody UpdateExperimentSetMembershipDTO updateExperimentSetMembershipDTO) { - var logger = logger(authentication, - "(PATCH) /experiment-folders/" + folderId + "/members/" + experimentUuid + "/set"); - logger.debug("Request to change the set of an experiment. RequestBody: " - + JsonConverters.convertObjectToJsonString(updateExperimentSetMembershipDTO)); - var folder = experimentFolderService.updateSetMembership(authentication, folderId, experimentUuid, - updateExperimentSetMembershipDTO, logger); - logger.info("Set membership updated."); - return new ResponseEntity<>(folder, HttpStatus.OK); - } - - private Logger logger(Authentication authentication, String endpoint) { - return new Logger(activeUserService.getActiveUser(authentication).username(), endpoint); - } -} diff --git a/src/main/java/hbp/mip/folder/ExperimentFolderDTO.java b/src/main/java/hbp/mip/folder/ExperimentFolderDTO.java deleted file mode 100644 index fd25d9a24..000000000 --- a/src/main/java/hbp/mip/folder/ExperimentFolderDTO.java +++ /dev/null @@ -1,38 +0,0 @@ -package hbp.mip.folder; - -import java.util.Comparator; -import java.util.List; - -/** - * Response shape of a folder. Matches the frontend ExperimentFolder model exactly, so swapping the - * localStorage service for this API is a transport change and not a model change. - * - * experimentIds is ordered by folder_position, sets by sort_order, and each set's experimentIds by - * set_position. Members in no set appear only in experimentIds — that is the implicit Ungrouped - * group the compare workspace derives. - */ -public record ExperimentFolderDTO( - String id, - String name, - List experimentIds, - List sets) { - - public static ExperimentFolderDTO from(ExperimentFolderDAO folder) { - List members = folder.getMembers().stream() - .sorted(Comparator.comparing(ExperimentFolderMemberDAO::getFolderPosition, - Comparator.nullsLast(Comparator.naturalOrder()))) - .toList(); - - List sets = folder.getSets().stream() - .sorted(Comparator.comparing(ExperimentSetDAO::getSortOrder, - Comparator.nullsLast(Comparator.naturalOrder()))) - .map(set -> ExperimentSetDTO.from(set, members)) - .toList(); - - return new ExperimentFolderDTO( - folder.getId().toString(), - folder.getName(), - members.stream().map(member -> member.getExperiment().getUuid().toString()).toList(), - sets); - } -} diff --git a/src/main/java/hbp/mip/folder/ExperimentFolderMemberDAO.java b/src/main/java/hbp/mip/folder/ExperimentFolderMemberDAO.java deleted file mode 100644 index aea801de3..000000000 --- a/src/main/java/hbp/mip/folder/ExperimentFolderMemberDAO.java +++ /dev/null @@ -1,71 +0,0 @@ -package hbp.mip.folder; - -import hbp.mip.experiment.ExperimentDAO; -import jakarta.persistence.Column; -import jakarta.persistence.Entity; -import jakarta.persistence.FetchType; -import jakarta.persistence.Id; -import jakarta.persistence.JoinColumn; -import jakarta.persistence.ManyToOne; -import jakarta.persistence.Table; -import lombok.Getter; -import lombok.NoArgsConstructor; -import lombok.Setter; - -import java.util.UUID; - -/** - * The membership of one experiment in one folder, with its place in both orderings. - * - * Exactly one row per (folder, experiment) — enforced by uq_experiment_folder_member — is what makes - * sets a strict partition: joining a set is a repoint of {@code experimentSet}, so the previous set - * gives the run up without a second delete. - * - * {@code experimentSet} null means "in the folder, ungrouped". Deleting the experiment drops the row - * (ON DELETE CASCADE); the service nulls the field itself when a set is deleted, so the JPA state - * matches the database rule instead of waiting for it. - */ -@Entity -@Getter -@Setter -@NoArgsConstructor -@Table(name = "experiment_folder_member") -public class ExperimentFolderMemberDAO { - - @Id - @Column(columnDefinition = "uuid", updatable = false) - private UUID id; - - @ManyToOne(fetch = FetchType.LAZY, optional = false) - @JoinColumn(name = "folder_id", columnDefinition = "uuid") - private ExperimentFolderDAO folder; - - // Deliberately lazy and not batch-annotated: Hibernate 7 rejects @BatchSize on a to-one, and every - // read here is `getExperiment().getUuid()`, which a proxy answers from its identifier alone. The DTO - // and the membership lookups therefore never issue a SELECT for the experiment itself. - @ManyToOne(fetch = FetchType.LAZY, optional = false) - @JoinColumn(name = "experiment_uuid", columnDefinition = "uuid") - private ExperimentDAO experiment; - - @ManyToOne(fetch = FetchType.LAZY) - @JoinColumn(name = "set_id", columnDefinition = "uuid") - private ExperimentSetDAO experimentSet; - - @Column(name = "folder_position", nullable = false) - private Integer folderPosition; - - @Column(name = "set_position") - private Integer setPosition; - - public ExperimentFolderMemberDAO(ExperimentFolderDAO folder, ExperimentDAO experiment, Integer folderPosition) { - this.id = UUID.randomUUID(); - this.folder = folder; - this.experiment = experiment; - this.folderPosition = folderPosition; - } - - /** Id comparison, not equals: one side may still be an uninitialized association proxy. */ - public boolean isIn(ExperimentSetDAO set) { - return experimentSet != null && set.getId() != null && set.getId().equals(experimentSet.getId()); - } -} diff --git a/src/main/java/hbp/mip/folder/ExperimentFolderRepository.java b/src/main/java/hbp/mip/folder/ExperimentFolderRepository.java deleted file mode 100644 index 256d15570..000000000 --- a/src/main/java/hbp/mip/folder/ExperimentFolderRepository.java +++ /dev/null @@ -1,37 +0,0 @@ -package hbp.mip.folder; - -import jakarta.persistence.LockModeType; -import org.springframework.data.jpa.repository.JpaRepository; -import org.springframework.data.jpa.repository.Lock; -import org.springframework.data.jpa.repository.Query; -import org.springframework.data.repository.query.Param; - -import java.util.List; -import java.util.Optional; -import java.util.UUID; - -/** - * Folder persistence. Ownership filtering happens in the service, on the user resolved from the token, - * so no query here is asked to trust an id that came from a request. - * - * JpaRepository rather than CrudRepository for two reasons: {@code saveAndFlush} writes inside the - * service transaction, so a unique-name race surfaces where it can still be answered 409 instead of - * arriving too late, at commit time, as a 500; and {@code findByIdForUpdate} locks the folder row so - * membership writes on one folder serialize instead of racing the member unique constraint. - */ -public interface ExperimentFolderRepository extends JpaRepository { - - /** The owner's folders in display order. Every folder-scoped read starts from here. */ - @Query("select folder from ExperimentFolderDAO folder " - + "where folder.owner.username = :username order by folder.sortOrder asc, folder.id asc") - List findOwnedFolders(@Param("username") String username); - - /** - * The folder, write-locked for the rest of the transaction. Member and set writes take this first, - * so the "is it already a member?" check runs after the competing writer committed and a duplicate - * insert is not attempted at all. Reads must keep using {@code findById}. - */ - @Lock(LockModeType.PESSIMISTIC_WRITE) - @Query("select folder from ExperimentFolderDAO folder where folder.id = :id") - Optional findByIdForUpdate(@Param("id") UUID id); -} diff --git a/src/main/java/hbp/mip/folder/ExperimentFolderService.java b/src/main/java/hbp/mip/folder/ExperimentFolderService.java deleted file mode 100644 index 706b506c4..000000000 --- a/src/main/java/hbp/mip/folder/ExperimentFolderService.java +++ /dev/null @@ -1,488 +0,0 @@ -package hbp.mip.folder; - -import hbp.mip.experiment.ExperimentDAO; -import hbp.mip.experiment.ExperimentService; -import hbp.mip.user.ActiveUserService; -import hbp.mip.user.UserDAO; -import hbp.mip.utils.Exceptions.BadRequestException; -import hbp.mip.utils.Exceptions.ConflictException; -import hbp.mip.utils.Exceptions.ExperimentNotFoundException; -import hbp.mip.utils.Logger; -import org.springframework.dao.DataIntegrityViolationException; -import org.springframework.security.core.Authentication; -import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Transactional; - -import java.sql.SQLException; -import java.util.Collection; -import java.util.Comparator; -import java.util.List; -import java.util.Locale; -import java.util.Objects; -import java.util.Optional; -import java.util.UUID; - -/** - * Owns experiment folders and the sets inside them. - * - * Two rules hold everywhere and are the reason this class exists at all: - * - * 1. Everything is scoped to the active user. A folder id that is not the caller's is a 404, never a - * 403, so the API never confirms that somebody else's id exists. - * 2. A folder holds experiment ids, never experiment copies. Membership is the only thing persisted - * here, so a renamed or re-shared run cannot go stale inside a folder. - * - * Name handling mirrors the frontend rules the folder chips already enforce (collapse whitespace, - * trim, 60 chars, case-insensitive uniqueness) so moving the store behind this API does not change - * what a user can type. - */ -@Service -public class ExperimentFolderService { - - static final int MAX_NAME_LENGTH = 60; - - private final ActiveUserService activeUserService; - private final ExperimentFolderRepository folderRepository; - private final ExperimentService experimentService; - - public ExperimentFolderService(ActiveUserService activeUserService, - ExperimentFolderRepository folderRepository, - ExperimentService experimentService) { - this.activeUserService = activeUserService; - this.folderRepository = folderRepository; - this.experimentService = experimentService; - } - - // ------------------------------------------------------------------ folders - - @Transactional(readOnly = true) - public ExperimentFoldersDTO getFolders(Authentication authentication, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - List folders = folderRepository.findOwnedFolders(user.username()); - logger.debug("Owned experiment folders found: " + folders.size()); - return ExperimentFoldersDTO.from(folders); - } - - @Transactional(readOnly = true) - public ExperimentFolderDTO getFolder(Authentication authentication, String folderId, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - return ExperimentFolderDTO.from(ownedFolder(folderId, user.username(), logger)); - } - - @Transactional - public ExperimentFolderDTO createFolder(Authentication authentication, CreateExperimentGroupDTO request, - Logger logger) { - var user = activeUserService.getActiveUser(authentication); - String name = requireName(request == null ? null : request.name(), "Folder name", logger); - - List ownedFolders = folderRepository.findOwnedFolders(user.username()); - rejectDuplicateFolderName(name, ownedFolders, null, logger); - - ExperimentFolderDAO folder = new ExperimentFolderDAO(new UserDAO(user), name, - nextPosition(ownedFolders.stream().map(ExperimentFolderDAO::getSortOrder).toList())); - - // "Put this run in a new folder" is one gesture in the row menu, so it is one request: a second - // call that fails would otherwise leave an empty folder the user never asked for. - String requestedExperiment = request == null ? null : request.experimentUuid(); - if (!isBlank(requestedExperiment)) { - memberFor(folder, experimentService.assertExperimentAccessible(authentication, requestedExperiment, logger), - logger); - } - - ExperimentFolderDAO saved = save(folder, "An experiment folder with that name already exists.", logger); - logger.info("Experiment folder created with id: " + saved.getId()); - return ExperimentFolderDTO.from(saved); - } - - @Transactional - public ExperimentFolderDTO renameFolder(Authentication authentication, String folderId, - RenameExperimentGroupDTO request, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolder(folderId, user.username(), logger); - - String name = requireName(request == null ? null : request.name(), "Folder name", logger); - rejectDuplicateFolderName(name, folderRepository.findOwnedFolders(user.username()), folder, logger); - - folder.setName(name); - - ExperimentFolderDAO saved = save(folder, "An experiment folder with that name already exists.", logger); - logger.info("Experiment folder renamed. Id: " + folder.getId()); - return ExperimentFolderDTO.from(saved); - } - - /** Deleting a folder retires the grouping only. The runs themselves are untouched. */ - @Transactional - public void deleteFolder(Authentication authentication, String folderId, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolder(folderId, user.username(), logger); - - folderRepository.delete(folder); - logger.info("Experiment folder deleted. Id: " + folder.getId()); - } - - // ------------------------------------------------------------------ members - - /** - * Adding a run the folder already holds returns the folder unchanged: the row menu can toggle blindly. - * - * The folder row is locked first, so a second add of the same run waits, then sees the membership and - * returns the folder; the member unique constraint is a backstop, not the path that decides this. - */ - @Transactional - public ExperimentFolderDTO addExperiment(Authentication authentication, String folderId, - AddExperimentFoldersMemberDTO request, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolderForUpdate(folderId, user.username(), logger); - - String experimentUuid = request == null ? null : request.experimentUuid(); - if (isBlank(experimentUuid)) { - String errorMessage = "experimentUuid must be provided."; - logger.warn(errorMessage); - throw new BadRequestException(errorMessage); - } - ExperimentDAO experiment = experimentService.assertExperimentAccessible(authentication, experimentUuid.trim(), - logger); - - if (memberOf(folder, experiment.getUuid()) != null) { - logger.info("Experiment already belongs to the folder. Id: " + experiment.getUuid()); - return ExperimentFolderDTO.from(folder); - } - - memberFor(folder, experiment, logger); - - ExperimentFolderDAO saved = save(folder, "That experiment already belongs to this folder.", logger); - logger.info("Experiment added to folder. Experiment id: " + experiment.getUuid()); - return ExperimentFolderDTO.from(saved); - } - - /** Leaving the folder ends the membership outright: a set cannot keep a run the folder lost. */ - @Transactional - public ExperimentFolderDTO removeExperiment(Authentication authentication, String folderId, String experimentUuid, - Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolderForUpdate(folderId, user.username(), logger); - - UUID experimentId = parseUuid(experimentUuid, "experimentUuid", logger); - ExperimentFolderMemberDAO member = memberOf(folder, experimentId); - if (member == null) { - logger.info("Experiment was not a member of the folder. Id: " + experimentUuid); - return ExperimentFolderDTO.from(folder); - } - - folder.getMembers().remove(member); - ExperimentFolderDAO saved = save(folder, "That experiment already belongs to this folder.", logger); - logger.info("Experiment removed from folder. Experiment id: " + experimentUuid); - return ExperimentFolderDTO.from(saved); - } - - // ------------------------------------------------------------------ sets - - @Transactional - public ExperimentFolderDTO createSet(Authentication authentication, String folderId, - CreateExperimentGroupDTO request, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolderForUpdate(folderId, user.username(), logger); - - String name = requireName(request == null ? null : request.name(), "Set name", logger); - rejectDuplicateSetName(name, folder, null, logger); - - ExperimentSetDAO set = new ExperimentSetDAO(folder, name, - nextPosition(folder.getSets().stream().map(ExperimentSetDAO::getSortOrder).toList())); - folder.getSets().add(set); - - String requestedExperiment = request == null ? null : request.experimentUuid(); - if (!isBlank(requestedExperiment)) { - ExperimentDAO experiment = experimentService.assertExperimentAccessible(authentication, requestedExperiment, logger); - joinSet(folder, memberFor(folder, experiment, logger), set); - } - - ExperimentFolderDAO saved = save(folder, "An experiment set with that name already exists in this folder.", logger); - logger.info("Experiment set created with id: " + set.getId()); - return ExperimentFolderDTO.from(saved); - } - - @Transactional - public ExperimentFolderDTO renameSet(Authentication authentication, String folderId, String setId, - RenameExperimentGroupDTO request, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolder(folderId, user.username(), logger); - ExperimentSetDAO set = ownedSet(folder, setId, logger); - - String name = requireName(request == null ? null : request.name(), "Set name", logger); - rejectDuplicateSetName(name, folder, set, logger); - - set.setName(name); - - ExperimentFolderDAO saved = save(folder, "An experiment set with that name already exists in this folder.", logger); - logger.info("Experiment set renamed. Id: " + set.getId()); - return ExperimentFolderDTO.from(saved); - } - - /** Deleting a set retires the name, never the runs: its members fall back to ungrouped. */ - @Transactional - public ExperimentFolderDTO deleteSet(Authentication authentication, String folderId, String setId, - Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolderForUpdate(folderId, user.username(), logger); - ExperimentSetDAO set = ownedSet(folder, setId, logger); - - // The database would settle this with ON DELETE SET NULL, but the flushed order between the - // set removal and the member updates is not ours to bet on: null them here so the in-memory - // state and the row agree either way. - folder.getMembers().stream() - .filter(member -> member.isIn(set)) - .forEach(this::ungroup); - - folder.getSets().remove(set); - ExperimentFolderDAO saved = save(folder, "An experiment set with that name already exists in this folder.", logger); - logger.info("Experiment set deleted. Runs were left in the folder, ungrouped. Set id: " + setId); - return ExperimentFolderDTO.from(saved); - } - - /** - * The strict partition: moving a run in files it nowhere else, so the previous set gives it up by - * itself — one row per (folder, experiment) means there is no second row to clean. - * - * A null or blank setId is the way out of a set that is not "leave the folder": the run stays in - * the folder and becomes ungrouped. - */ - @Transactional - public ExperimentFolderDTO updateSetMembership(Authentication authentication, String folderId, String experimentUuid, - UpdateExperimentSetMembershipDTO request, Logger logger) { - var user = activeUserService.getActiveUser(authentication); - ExperimentFolderDAO folder = ownedFolderForUpdate(folderId, user.username(), logger); - - UUID experimentId = parseUuid(experimentUuid, "experimentUuid", logger); - ExperimentFolderMemberDAO existingMember = memberOf(folder, experimentId); - - String requestedSetId = request == null ? null : request.setId(); - if (isBlank(requestedSetId)) { - if (existingMember == null || (existingMember.getExperimentSet() == null - && existingMember.getSetPosition() == null)) { - logger.info("Experiment is already ungrouped in the folder. Id: " + experimentUuid); - return ExperimentFolderDTO.from(folder); - } - - ungroup(existingMember); - ExperimentFolderDAO ungrouped = save(folder, "That experiment already belongs to this folder.", logger); - logger.info("Experiment left its set and stayed in the folder. Id: " + experimentUuid); - return ExperimentFolderDTO.from(ungrouped); - } - - ExperimentSetDAO target = ownedSet(folder, requestedSetId, logger); - ExperimentFolderMemberDAO member = existingMember != null - ? existingMember - : memberFor(folder, experimentService.assertExperimentAccessible(authentication, experimentUuid, logger), logger); - - if (member.isIn(target)) { - logger.info("Experiment is already in the requested set. Id: " + experimentUuid); - return ExperimentFolderDTO.from(folder); - } - - joinSet(folder, member, target); - ExperimentFolderDAO saved = save(folder, "That experiment already belongs to this folder.", logger); - logger.info("Experiment moved to set " + target.getId() + ". Experiment id: " + experimentUuid); - return ExperimentFolderDTO.from(saved); - } - - // ------------------------------------------------------------------ shared rules - - /** - * A folder the caller may touch, or nothing. A folder that exists under another owner and a folder - * that does not exist answer the same 404, so the API never confirms somebody else's id. - */ - private ExperimentFolderDAO ownedFolder(String folderId, String username, Logger logger) { - return ownedFolder(folderRepository.findById(parseUuid(folderId, "folderId", logger)), folderId, username, - logger); - } - - /** - * The same folder, write-locked for the rest of the transaction. Membership writes take this before - * they look at {@code members}: two concurrent add/move calls on one folder then queue on the row - * lock, so the second sees the first's membership and no duplicate row is ever attempted. - * - * The lock itself needs the transaction the service methods already declare. - */ - private ExperimentFolderDAO ownedFolderForUpdate(String folderId, String username, Logger logger) { - return ownedFolder(folderRepository.findByIdForUpdate(parseUuid(folderId, "folderId", logger)), folderId, - username, logger); - } - - private ExperimentFolderDAO ownedFolder(Optional candidate, String folderId, String username, - Logger logger) { - ExperimentFolderDAO folder = candidate - .filter(candidateFolder -> candidateFolder.getOwner() != null - && username.equals(candidateFolder.getOwner().getUsername())) - .orElse(null); - - if (folder == null) { - var errorMessage = "Experiment folder with id : " + folderId + " was not found for the active user."; - logger.warn(errorMessage); - throw new ExperimentNotFoundException(errorMessage); - } - - return folder; - } - - /** - * Writes and flushes in one go, then translates the database's own uniqueness backstop into the - * 409 the caller already got from the pre-check. Two tabs creating the same folder name both pass - * the service check; whichever insert loses must hear "conflict", not "internal server error". - * Only unique violations are translated — a NOT NULL or FK failure is still our bug and stays a 500. - */ - private ExperimentFolderDAO save(ExperimentFolderDAO folder, String duplicateMessage, Logger logger) { - try { - return folderRepository.saveAndFlush(folder); - } catch (DataIntegrityViolationException failure) { - if (!isUniqueViolation(failure)) { - throw failure; - } - logger.warn(duplicateMessage); - throw new ConflictException(duplicateMessage); - } - } - - /** PostgreSQL reports unique violations as SQLSTATE 23505; anything else (NOT NULL, FK) stays a 500. */ - private boolean isUniqueViolation(Throwable failure) { - for (Throwable cause = failure; cause != null; cause = cause.getCause()) { - if (cause instanceof SQLException sql) { - return "23505".equals(sql.getSQLState()); - } - } - return false; - } - - private ExperimentFolderMemberDAO memberOf(ExperimentFolderDAO folder, UUID experimentUuid) { - return folder.getMembers().stream() - .filter(member -> member.getExperiment() != null - && experimentUuid.equals(member.getExperiment().getUuid())) - .findFirst() - .orElse(null); - } - - private ExperimentSetDAO ownedSet(ExperimentFolderDAO folder, String setId, Logger logger) { - UUID parsed = parseUuid(setId, "setId", logger); - ExperimentSetDAO set = folder.getSets().stream() - .filter(candidate -> parsed.equals(candidate.getId())) - .findFirst() - .orElse(null); - if (set == null) { - var errorMessage = "Experiment set with id : " + setId + " was not found in folder : " + folder.getId(); - logger.warn(errorMessage); - throw new ExperimentNotFoundException(errorMessage); - } - return set; - } - - /** A set only ever holds folder members, so moving in joins the folder first when it has to. */ - private ExperimentFolderMemberDAO memberFor(ExperimentFolderDAO folder, ExperimentDAO experiment, Logger logger) { - ExperimentFolderMemberDAO member = memberOf(folder, experiment.getUuid()); - if (member == null) { - member = new ExperimentFolderMemberDAO(folder, experiment, - nextPosition(folderPositions(folder))); - folder.getMembers().add(member); - logger.debug("Folder membership created while placing the run in a set."); - } - return member; - } - - private void joinSet(ExperimentFolderDAO folder, ExperimentFolderMemberDAO member, ExperimentSetDAO target) { - member.setExperimentSet(target); - - // The run being moved is excluded from the max: it cannot count the position it is leaving. - member.setSetPosition(nextPosition(folder.getMembers().stream() - .filter(other -> !Objects.equals(other, member)) - .filter(other -> other.isIn(target)) - .map(ExperimentFolderMemberDAO::getSetPosition) - .toList())); - } - - private List folderPositions(ExperimentFolderDAO folder) { - return folder.getMembers().stream() - .map(ExperimentFolderMemberDAO::getFolderPosition) - .toList(); - } - - private void ungroup(ExperimentFolderMemberDAO member) { - member.setExperimentSet(null); - member.setSetPosition(null); - } - - /** New entries land last, in whichever axis is being appended to: first is 1, then max + 1. */ - private Integer nextPosition(Collection positions) { - return positions.stream() - .filter(Objects::nonNull) - .max(Comparator.naturalOrder()) - .map(last -> last + 1) - .orElse(1); - } - - private String requireName(String rawName, String field, Logger logger) { - String name = normalizeName(rawName); - if (name.isEmpty()) { - String errorMessage = field + " must not be blank."; - logger.warn(errorMessage); - throw new BadRequestException(errorMessage); - } - return name; - } - - /** Whitespace runs collapse to one space, the ends are trimmed, and 60 chars is all that fits. */ - private String normalizeName(String rawName) { - if (rawName == null) { - return ""; - } - String cleaned = rawName.replaceAll("\\s+", " ").trim(); - return cleaned.length() <= MAX_NAME_LENGTH ? cleaned : cleaned.substring(0, MAX_NAME_LENGTH); - } - - /** Comparison key only — the stored name keeps the casing the user typed. */ - private String nameKey(String name) { - return normalizeName(name).toLowerCase(Locale.ROOT); - } - - private void rejectDuplicateFolderName(String name, List ownedFolders, - ExperimentFolderDAO renamed, Logger logger) { - boolean taken = ownedFolders.stream() - .filter(folder -> renamed == null || !folder.getId().equals(renamed.getId())) - .anyMatch(folder -> nameKey(folder.getName()).equals(nameKey(name))); - - if (taken) { - String errorMessage = "An experiment folder named '" + name + "' already exists."; - logger.warn(errorMessage); - throw new ConflictException(errorMessage); - } - } - - /** Sets are their own namespace: a set may share its folder's name, but not a sibling's. */ - private void rejectDuplicateSetName(String name, ExperimentFolderDAO folder, ExperimentSetDAO renamed, - Logger logger) { - boolean taken = folder.getSets().stream() - .filter(set -> renamed == null || !set.getId().equals(renamed.getId())) - .anyMatch(set -> nameKey(set.getName()).equals(nameKey(name))); - - if (taken) { - String errorMessage = "An experiment set named '" + name + "' already exists in this folder."; - logger.warn(errorMessage); - throw new ConflictException(errorMessage); - } - } - - private UUID parseUuid(String value, String field, Logger logger) { - if (isBlank(value)) { - String errorMessage = field + " must be provided."; - logger.warn(errorMessage); - throw new BadRequestException(errorMessage); - } - try { - return UUID.fromString(value.trim()); - } catch (IllegalArgumentException e) { - logger.error("Conversion of string to UUID failed: " + e.getMessage()); - throw new BadRequestException("Invalid " + field + ": " + value); - } - } - - private boolean isBlank(String value) { - return value == null || value.trim().isEmpty(); - } -} diff --git a/src/main/java/hbp/mip/folder/ExperimentFoldersDTO.java b/src/main/java/hbp/mip/folder/ExperimentFoldersDTO.java deleted file mode 100644 index 69aed3f39..000000000 --- a/src/main/java/hbp/mip/folder/ExperimentFoldersDTO.java +++ /dev/null @@ -1,11 +0,0 @@ -package hbp.mip.folder; - -import java.util.List; - -/** Response shape of the collection endpoint. An owner with no folders gets an empty list, not a 404. */ -public record ExperimentFoldersDTO(List folders) { - - public static ExperimentFoldersDTO from(List folders) { - return new ExperimentFoldersDTO(folders.stream().map(ExperimentFolderDTO::from).toList()); - } -} diff --git a/src/main/java/hbp/mip/folder/ExperimentSetDTO.java b/src/main/java/hbp/mip/folder/ExperimentSetDTO.java deleted file mode 100644 index c8bd8b4d6..000000000 --- a/src/main/java/hbp/mip/folder/ExperimentSetDTO.java +++ /dev/null @@ -1,25 +0,0 @@ -package hbp.mip.folder; - -import java.util.Comparator; -import java.util.List; - -/** - * Response shape of a set. Matches the frontend ExperimentSet model: id, name, member ids only — - * never experiment copies, so a folder can never serve a stale run. - * - * experimentIds is ordered by set_position; nulls sort last so an unpositioned row cannot scramble - * the section. - */ -public record ExperimentSetDTO(String id, String name, List experimentIds) { - - public static ExperimentSetDTO from(ExperimentSetDAO set, List members) { - List memberIds = members.stream() - .filter(member -> member.isIn(set)) - .sorted(Comparator.comparing(ExperimentFolderMemberDAO::getSetPosition, - Comparator.nullsLast(Comparator.naturalOrder()))) - .map(member -> member.getExperiment().getUuid().toString()) - .toList(); - - return new ExperimentSetDTO(set.getId().toString(), set.getName(), memberIds); - } -} diff --git a/src/main/java/hbp/mip/folder/RenameExperimentGroupDTO.java b/src/main/java/hbp/mip/folder/RenameExperimentGroupDTO.java deleted file mode 100644 index 8c71304b7..000000000 --- a/src/main/java/hbp/mip/folder/RenameExperimentGroupDTO.java +++ /dev/null @@ -1,5 +0,0 @@ -package hbp.mip.folder; - -/** Request body of "rename folder" and "rename set". Only the name is editable, and it follows the create rules. */ -public record RenameExperimentGroupDTO(String name) { -} diff --git a/src/main/java/hbp/mip/folder/UpdateExperimentSetMembershipDTO.java b/src/main/java/hbp/mip/folder/UpdateExperimentSetMembershipDTO.java deleted file mode 100644 index 93dec9211..000000000 --- a/src/main/java/hbp/mip/folder/UpdateExperimentSetMembershipDTO.java +++ /dev/null @@ -1,11 +0,0 @@ -package hbp.mip.folder; - -/** - * Request body of "which set holds this run". - * - * A null or blank setId means "ungroup": the run stays in the folder and leaves its set. One body - * covers both the move and the way out, and the strict partition means a move never needs to name - * the set it leaves. - */ -public record UpdateExperimentSetMembershipDTO(String setId) { -} diff --git a/src/main/java/hbp/mip/study/AddStudyMemberDTO.java b/src/main/java/hbp/mip/study/AddStudyMemberDTO.java new file mode 100644 index 000000000..bc3849709 --- /dev/null +++ b/src/main/java/hbp/mip/study/AddStudyMemberDTO.java @@ -0,0 +1,5 @@ +package hbp.mip.study; + +/** Request body of "add a run to a study". Re-adding an existing member is a no-op, not an error. */ +public record AddStudyMemberDTO(String analysisId) { +} diff --git a/src/main/java/hbp/mip/folder/ExperimentSetDAO.java b/src/main/java/hbp/mip/study/AnalysisGroupDAO.java similarity index 55% rename from src/main/java/hbp/mip/folder/ExperimentSetDAO.java rename to src/main/java/hbp/mip/study/AnalysisGroupDAO.java index 8a289e01e..79b240c76 100644 --- a/src/main/java/hbp/mip/folder/ExperimentSetDAO.java +++ b/src/main/java/hbp/mip/study/AnalysisGroupDAO.java @@ -1,4 +1,4 @@ -package hbp.mip.folder; +package hbp.mip.study; import jakarta.persistence.Column; import jakarta.persistence.Entity; @@ -15,28 +15,28 @@ import java.util.UUID; /** - * A named subset of a folder's members: the unit the compare workspace renders as a section. + * A named subset of a study's members: the unit the compare workspace renders as a section. * - * Membership lives on {@link ExperimentFolderMemberDAO#getExperimentSet()}, not here, because a run - * can only ever sit in one set per folder; a set is therefore just a name plus an ordering. + * Membership lives on {@link StudyMemberDAO#getAnalysisGroup()}, not here, because a run + * can only ever sit in one group per study; a group is therefore just a name plus an ordering. * - * Sets are their own namespace: a set may carry the same name as the folder that holds it, but not - * the same name as a sibling set (uq_experiment_set_folder_name). + * Groups are their own namespace: a group may carry the same name as the study that holds it, but not + * the same name as a sibling group (uq_analysis_group_study_name). */ @Entity @Getter @Setter @NoArgsConstructor -@Table(name = "experiment_set") -public class ExperimentSetDAO { +@Table(name = "analysis_group") +public class AnalysisGroupDAO { @Id @Column(columnDefinition = "uuid", updatable = false) private UUID id; @ManyToOne(fetch = FetchType.LAZY, optional = false) - @JoinColumn(name = "folder_id", columnDefinition = "uuid") - private ExperimentFolderDAO folder; + @JoinColumn(name = "study_id", columnDefinition = "uuid") + private StudyDAO study; @Column(nullable = false, columnDefinition = "TEXT") private String name; @@ -47,9 +47,9 @@ public class ExperimentSetDAO { @Column(columnDefinition = "TIMESTAMP WITHOUT TIME ZONE") private Date created = new Date(); - public ExperimentSetDAO(ExperimentFolderDAO folder, String name, Integer sortOrder) { + public AnalysisGroupDAO(StudyDAO study, String name, Integer sortOrder) { this.id = UUID.randomUUID(); - this.folder = folder; + this.study = study; this.name = name; this.sortOrder = sortOrder; } diff --git a/src/main/java/hbp/mip/study/AnalysisGroupDTO.java b/src/main/java/hbp/mip/study/AnalysisGroupDTO.java new file mode 100644 index 000000000..f334e373d --- /dev/null +++ b/src/main/java/hbp/mip/study/AnalysisGroupDTO.java @@ -0,0 +1,25 @@ +package hbp.mip.study; + +import java.util.Comparator; +import java.util.List; + +/** + * Response shape of a group. Matches the frontend AnalysisGroup model: id, name, member ids only — + * never analysis copies, so a study can never serve a stale run. + * + * analysisIds is ordered by group_position; nulls sort last so an unpositioned row cannot scramble + * the section. + */ +public record AnalysisGroupDTO(String id, String name, List analysisIds) { + + public static AnalysisGroupDTO from(AnalysisGroupDAO group, List members) { + List memberIds = members.stream() + .filter(member -> member.isIn(group)) + .sorted(Comparator.comparing(StudyMemberDAO::getGroupPosition, + Comparator.nullsLast(Comparator.naturalOrder()))) + .map(member -> member.getAnalysis().getUuid().toString()) + .toList(); + + return new AnalysisGroupDTO(group.getId().toString(), group.getName(), memberIds); + } +} diff --git a/src/main/java/hbp/mip/study/CreateAnalysisGroupDTO.java b/src/main/java/hbp/mip/study/CreateAnalysisGroupDTO.java new file mode 100644 index 000000000..bc7e8da72 --- /dev/null +++ b/src/main/java/hbp/mip/study/CreateAnalysisGroupDTO.java @@ -0,0 +1,9 @@ +package hbp.mip.study; + +/** + * Creates an Analysis Group. The id and order are assigned by the service. + * + * An optional Analysis joins the Study and group in the same transaction. + */ +public record CreateAnalysisGroupDTO(String name, String analysisId) { +} diff --git a/src/main/java/hbp/mip/study/CreateStudyDTO.java b/src/main/java/hbp/mip/study/CreateStudyDTO.java new file mode 100644 index 000000000..ae7c57069 --- /dev/null +++ b/src/main/java/hbp/mip/study/CreateStudyDTO.java @@ -0,0 +1,5 @@ +package hbp.mip.study; + +/** Creates a Study, optionally with its first Analysis, in one transaction. */ +public record CreateStudyDTO(String name, String analysisId) { +} diff --git a/src/main/java/hbp/mip/study/RenameAnalysisGroupDTO.java b/src/main/java/hbp/mip/study/RenameAnalysisGroupDTO.java new file mode 100644 index 000000000..57e8c9157 --- /dev/null +++ b/src/main/java/hbp/mip/study/RenameAnalysisGroupDTO.java @@ -0,0 +1,5 @@ +package hbp.mip.study; + +/** Renames an Analysis Group using the same name rules as creation. */ +public record RenameAnalysisGroupDTO(String name) { +} diff --git a/src/main/java/hbp/mip/study/RenameStudyDTO.java b/src/main/java/hbp/mip/study/RenameStudyDTO.java new file mode 100644 index 000000000..dc0cd712a --- /dev/null +++ b/src/main/java/hbp/mip/study/RenameStudyDTO.java @@ -0,0 +1,4 @@ +package hbp.mip.study; + +public record RenameStudyDTO(String name) { +} diff --git a/src/main/java/hbp/mip/study/StudiesDTO.java b/src/main/java/hbp/mip/study/StudiesDTO.java new file mode 100644 index 000000000..543a48766 --- /dev/null +++ b/src/main/java/hbp/mip/study/StudiesDTO.java @@ -0,0 +1,11 @@ +package hbp.mip.study; + +import java.util.List; + +/** Response shape of the collection endpoint. An owner with no studies gets an empty list, not a 404. */ +public record StudiesDTO(List studies) { + + public static StudiesDTO from(List studies) { + return new StudiesDTO(studies.stream().map(StudyDTO::from).toList()); + } +} diff --git a/src/main/java/hbp/mip/study/StudyAPI.java b/src/main/java/hbp/mip/study/StudyAPI.java new file mode 100644 index 000000000..f14d1ee12 --- /dev/null +++ b/src/main/java/hbp/mip/study/StudyAPI.java @@ -0,0 +1,181 @@ +package hbp.mip.study; + +import hbp.mip.user.ActiveUserService; +import hbp.mip.utils.JsonConverters; +import hbp.mip.utils.Logger; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.security.core.Authentication; +import org.springframework.web.bind.annotation.DeleteMapping; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PatchMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.PostMapping; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE; + +/** + * Studies and the Analysis Groups inside them, for the active user only. + * + * Routes sit under the /services servlet context, so the public paths are + * /services/studies/.... + * + * Statuses: 200 for reads and for every mutation that leaves a study behind — the updated study is + * the body, so the caller never has to guess at ordering or partitioning — 201 for a new study or group, + * 204 only when the study itself is gone, 400 for a blank or malformed name/id, 404 when the study or + * group is not the caller's, 409 for a duplicate name, 403 when the Analysis cannot be read. + */ +@RestController +@RequestMapping(value = "/studies", produces = { APPLICATION_JSON_VALUE }) +public class StudyAPI { + + private final StudyService studyService; + private final ActiveUserService activeUserService; + + public StudyAPI(StudyService studyService, + ActiveUserService activeUserService) { + this.studyService = studyService; + this.activeUserService = activeUserService; + } + + @GetMapping + public ResponseEntity getStudies(Authentication authentication) { + var logger = logger(authentication, "(GET) /studies"); + logger.info("Request for the studies of the active user."); + var studies = studyService.getStudies(authentication, logger); + logger.info("Studies returned: " + studies.studies().size()); + return new ResponseEntity<>(studies, HttpStatus.OK); + } + + @PostMapping + public ResponseEntity createStudy(Authentication authentication, + @RequestBody CreateStudyDTO createStudyDTO) { + var logger = logger(authentication, "(POST) /studies"); + logger.debug("Request for study creation. RequestBody: " + + JsonConverters.convertObjectToJsonString(createStudyDTO)); + var study = studyService.createStudy(authentication, createStudyDTO, logger); + logger.info("Study created with id: " + study.id()); + return new ResponseEntity<>(study, HttpStatus.CREATED); + } + + @GetMapping(value = "/{studyId}") + public ResponseEntity getStudy(Authentication authentication, + @PathVariable("studyId") String studyId) { + var logger = logger(authentication, "(GET) /studies/" + studyId); + logger.info("Request for study with id: " + studyId); + var study = studyService.getStudy(authentication, studyId, logger); + logger.info("Study returned."); + return new ResponseEntity<>(study, HttpStatus.OK); + } + + @PatchMapping(value = "/{studyId}") + public ResponseEntity renameStudy(Authentication authentication, + @PathVariable("studyId") String studyId, + @RequestBody RenameStudyDTO renameStudyDTO) { + var logger = logger(authentication, "(PATCH) /studies/" + studyId); + logger.debug("Request for study rename. RequestBody: " + + JsonConverters.convertObjectToJsonString(renameStudyDTO)); + var study = studyService.renameStudy(authentication, studyId, renameStudyDTO, logger); + logger.info("Study renamed. Id: " + studyId); + return new ResponseEntity<>(study, HttpStatus.OK); + } + + @DeleteMapping(value = "/{studyId}") + public ResponseEntity deleteStudy(Authentication authentication, + @PathVariable("studyId") String studyId) { + var logger = logger(authentication, "(DELETE) /studies/" + studyId); + logger.info("Request for study deletion with id: " + studyId); + studyService.deleteStudy(authentication, studyId, logger); + logger.info("Study deleted. Id: " + studyId); + return new ResponseEntity<>(HttpStatus.NO_CONTENT); + } + + /** Adding a run the study already holds answers 200 with the study, not 409. */ + @PostMapping(value = "/{studyId}/members") + public ResponseEntity addAnalysis(Authentication authentication, + @PathVariable("studyId") String studyId, + @RequestBody AddStudyMemberDTO addStudyMemberDTO) { + var logger = logger(authentication, "(POST) /studies/" + studyId + "/members"); + logger.debug("Request for analysis addition to a study. RequestBody: " + + JsonConverters.convertObjectToJsonString(addStudyMemberDTO)); + var study = studyService.addAnalysis(authentication, studyId, addStudyMemberDTO, + logger); + logger.info("Analysis added to the study."); + return new ResponseEntity<>(study, HttpStatus.OK); + } + + /** Answers with the study rather than 204: losing a member changes the member list and a group. */ + @DeleteMapping(value = "/{studyId}/members/{analysisId}") + public ResponseEntity removeAnalysis(Authentication authentication, + @PathVariable("studyId") String studyId, + @PathVariable("analysisId") String analysisId) { + var logger = logger(authentication, "(DELETE) /studies/" + studyId + "/members/" + analysisId); + logger.info("Request to remove analysis " + analysisId + " from study " + studyId); + var study = studyService.removeAnalysis(authentication, studyId, analysisId, logger); + logger.info("Analysis removed from the study."); + return new ResponseEntity<>(study, HttpStatus.OK); + } + + @PostMapping(value = "/{studyId}/groups") + public ResponseEntity createGroup(Authentication authentication, + @PathVariable("studyId") String studyId, + @RequestBody CreateAnalysisGroupDTO createAnalysisGroupDTO) { + var logger = logger(authentication, "(POST) /studies/" + studyId + "/groups"); + logger.debug("Request for analysis group creation. RequestBody: " + + JsonConverters.convertObjectToJsonString(createAnalysisGroupDTO)); + var study = studyService.createGroup(authentication, studyId, createAnalysisGroupDTO, logger); + logger.info("Analysis group created in study: " + studyId); + return new ResponseEntity<>(study, HttpStatus.CREATED); + } + + @PatchMapping(value = "/{studyId}/groups/{groupId}") + public ResponseEntity renameGroup(Authentication authentication, + @PathVariable("studyId") String studyId, + @PathVariable("groupId") String groupId, + @RequestBody RenameAnalysisGroupDTO renameAnalysisGroupDTO) { + var logger = logger(authentication, "(PATCH) /studies/" + studyId + "/groups/" + groupId); + logger.debug("Request for analysis group rename. RequestBody: " + + JsonConverters.convertObjectToJsonString(renameAnalysisGroupDTO)); + var study = studyService.renameGroup(authentication, studyId, groupId, renameAnalysisGroupDTO, logger); + logger.info("Analysis group renamed. Id: " + groupId); + return new ResponseEntity<>(study, HttpStatus.OK); + } + + /** Answers with the study rather than 204: the retired group moved its runs into Ungrouped. */ + @DeleteMapping(value = "/{studyId}/groups/{groupId}") + public ResponseEntity deleteGroup(Authentication authentication, + @PathVariable("studyId") String studyId, + @PathVariable("groupId") String groupId) { + var logger = logger(authentication, "(DELETE) /studies/" + studyId + "/groups/" + groupId); + logger.info("Request for analysis group deletion with id: " + groupId); + var study = studyService.deleteGroup(authentication, studyId, groupId, logger); + logger.info("Analysis group deleted. Its runs were left in the study, ungrouped."); + return new ResponseEntity<>(study, HttpStatus.OK); + } + + /** + * Moves a run into a group — or, with a null groupId, out of its group and back to ungrouped. The run + * stays in the study either way. + */ + @PatchMapping(value = "/{studyId}/members/{analysisId}/group") + public ResponseEntity updateGroupMembership(Authentication authentication, + @PathVariable("studyId") String studyId, + @PathVariable("analysisId") String analysisId, + @RequestBody UpdateAnalysisGroupMembershipDTO updateAnalysisGroupMembershipDTO) { + var logger = logger(authentication, + "(PATCH) /studies/" + studyId + "/members/" + analysisId + "/group"); + logger.debug("Request to change the group of an analysis. RequestBody: " + + JsonConverters.convertObjectToJsonString(updateAnalysisGroupMembershipDTO)); + var study = studyService.updateGroupMembership(authentication, studyId, analysisId, + updateAnalysisGroupMembershipDTO, logger); + logger.info("Group membership updated."); + return new ResponseEntity<>(study, HttpStatus.OK); + } + + private Logger logger(Authentication authentication, String endpoint) { + return new Logger(activeUserService.getActiveUser(authentication).username(), endpoint); + } +} diff --git a/src/main/java/hbp/mip/folder/ExperimentFolderDAO.java b/src/main/java/hbp/mip/study/StudyDAO.java similarity index 63% rename from src/main/java/hbp/mip/folder/ExperimentFolderDAO.java rename to src/main/java/hbp/mip/study/StudyDAO.java index f1a28e3c6..1a5c7befb 100644 --- a/src/main/java/hbp/mip/folder/ExperimentFolderDAO.java +++ b/src/main/java/hbp/mip/study/StudyDAO.java @@ -1,4 +1,4 @@ -package hbp.mip.folder; +package hbp.mip.study; import hbp.mip.user.UserDAO; import jakarta.persistence.CascadeType; @@ -22,20 +22,20 @@ import java.util.UUID; /** - * A user-curated group of experiment runs (an "analysis set" in the UI). + * A user-owned Study containing Analysis memberships and Analysis Groups. * - * The folder owns its sets and its members: deleting a folder takes its grouping with it, never the - * experiments themselves, which stay in the experiment table. + * The study owns its groups and its members: deleting a study takes its grouping with it, never the + * analyses themselves, which stay in the analysis table. * - * Names are unique per owner ignoring case (uq_experiment_folder_owner_name), and the service + * Names are unique per owner ignoring case (uq_study_owner_name), and the service * rejects the duplicate with 409 before the database ever sees it. */ @Entity @Getter @Setter @NoArgsConstructor -@Table(name = "experiment_folder") -public class ExperimentFolderDAO { +@Table(name = "study") +public class StudyDAO { @Id @Column(columnDefinition = "uuid", updatable = false) @@ -55,18 +55,18 @@ public class ExperimentFolderDAO { private Date created = new Date(); // Batched rather than join-fetched: two bags on one entity cannot be fetched in a single join, and - // the list endpoint reads many folders at once, so one statement per collection beats one per folder. + // the list endpoint reads many studies at once, so one statement per collection beats one per study. @BatchSize(size = 50) - @OneToMany(mappedBy = "folder", cascade = CascadeType.ALL, orphanRemoval = true) + @OneToMany(mappedBy = "study", cascade = CascadeType.ALL, orphanRemoval = true) @OrderBy("sortOrder ASC") - private List sets = new ArrayList<>(); + private List groups = new ArrayList<>(); @BatchSize(size = 50) - @OneToMany(mappedBy = "folder", cascade = CascadeType.ALL, orphanRemoval = true) - @OrderBy("folderPosition ASC") - private List members = new ArrayList<>(); + @OneToMany(mappedBy = "study", cascade = CascadeType.ALL, orphanRemoval = true) + @OrderBy("studyPosition ASC") + private List members = new ArrayList<>(); - public ExperimentFolderDAO(UserDAO owner, String name, Integer sortOrder) { + public StudyDAO(UserDAO owner, String name, Integer sortOrder) { this.id = UUID.randomUUID(); this.owner = owner; this.name = name; diff --git a/src/main/java/hbp/mip/study/StudyDTO.java b/src/main/java/hbp/mip/study/StudyDTO.java new file mode 100644 index 000000000..2842f836f --- /dev/null +++ b/src/main/java/hbp/mip/study/StudyDTO.java @@ -0,0 +1,37 @@ +package hbp.mip.study; + +import java.util.Comparator; +import java.util.List; + +/** + * Ordered Study membership and group references for the frontend contract. + * + * analysisIds is ordered by study_position, groups by sort_order, and each group's analysisIds by + * group_position. Members in no group appear only in analysisIds — that is the implicit Ungrouped + * group the compare workspace derives. + */ +public record StudyDTO( + String id, + String name, + List analysisIds, + List groups) { + + public static StudyDTO from(StudyDAO study) { + List members = study.getMembers().stream() + .sorted(Comparator.comparing(StudyMemberDAO::getStudyPosition, + Comparator.nullsLast(Comparator.naturalOrder()))) + .toList(); + + List groups = study.getGroups().stream() + .sorted(Comparator.comparing(AnalysisGroupDAO::getSortOrder, + Comparator.nullsLast(Comparator.naturalOrder()))) + .map(group -> AnalysisGroupDTO.from(group, members)) + .toList(); + + return new StudyDTO( + study.getId().toString(), + study.getName(), + members.stream().map(member -> member.getAnalysis().getUuid().toString()).toList(), + groups); + } +} diff --git a/src/main/java/hbp/mip/study/StudyMemberDAO.java b/src/main/java/hbp/mip/study/StudyMemberDAO.java new file mode 100644 index 000000000..b4a8e78c1 --- /dev/null +++ b/src/main/java/hbp/mip/study/StudyMemberDAO.java @@ -0,0 +1,71 @@ +package hbp.mip.study; + +import hbp.mip.analysis.AnalysisDAO; +import jakarta.persistence.Column; +import jakarta.persistence.Entity; +import jakarta.persistence.FetchType; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.ManyToOne; +import jakarta.persistence.Table; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +import java.util.UUID; + +/** + * The membership of one analysis in one study, with its place in both orderings. + * + * Exactly one row per (study, analysis) — enforced by uq_study_member — is what makes + * groups a strict partition: joining a group is a repoint of {@code analysisGroup}, so the previous group + * gives the run up without a second delete. + * + * {@code analysisGroup} null means "in the study, ungrouped". Deleting the analysis drops the row + * (ON DELETE CASCADE); the service nulls the field itself when a group is deleted, so the JPA state + * matches the database rule instead of waiting for it. + */ +@Entity +@Getter +@Setter +@NoArgsConstructor +@Table(name = "study_member") +public class StudyMemberDAO { + + @Id + @Column(columnDefinition = "uuid", updatable = false) + private UUID id; + + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "study_id", columnDefinition = "uuid") + private StudyDAO study; + + // Deliberately lazy and not batch-annotated: Hibernate 7 rejects @BatchSize on a to-one, and every + // read here is `getAnalysis().getUuid()`, which a proxy answers from its identifier alone. The DTO + // and the membership lookups therefore never issue a SELECT for the analysis itself. + @ManyToOne(fetch = FetchType.LAZY, optional = false) + @JoinColumn(name = "analysis_id", columnDefinition = "uuid") + private AnalysisDAO analysis; + + @ManyToOne(fetch = FetchType.LAZY) + @JoinColumn(name = "group_id", columnDefinition = "uuid") + private AnalysisGroupDAO analysisGroup; + + @Column(name = "study_position", nullable = false) + private Integer studyPosition; + + @Column(name = "group_position") + private Integer groupPosition; + + public StudyMemberDAO(StudyDAO study, AnalysisDAO analysis, Integer studyPosition) { + this.id = UUID.randomUUID(); + this.study = study; + this.analysis = analysis; + this.studyPosition = studyPosition; + } + + /** Id comparison, not equals: one side may still be an uninitialized association proxy. */ + public boolean isIn(AnalysisGroupDAO group) { + return analysisGroup != null && group.getId() != null && group.getId().equals(analysisGroup.getId()); + } +} diff --git a/src/main/java/hbp/mip/study/StudyRepository.java b/src/main/java/hbp/mip/study/StudyRepository.java new file mode 100644 index 000000000..2fd5e66e2 --- /dev/null +++ b/src/main/java/hbp/mip/study/StudyRepository.java @@ -0,0 +1,37 @@ +package hbp.mip.study; + +import jakarta.persistence.LockModeType; +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Lock; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +/** + * Study persistence. Ownership filtering happens in the service, on the user resolved from the token, + * so no query here is asked to trust an id that came from a request. + * + * JpaRepository rather than CrudRepository for two reasons: {@code saveAndFlush} writes inside the + * service transaction, so a unique-name race surfaces where it can still be answered 409 instead of + * arriving too late, at commit time, as a 500; and {@code findByIdForUpdate} locks the study row so + * membership writes on one study serialize instead of racing the member unique constraint. + */ +public interface StudyRepository extends JpaRepository { + + /** The owner's studies in display order. Every study-scoped read starts from here. */ + @Query("select study from StudyDAO study " + + "where study.owner.username = :username order by study.sortOrder asc, study.id asc") + List findOwnedStudies(@Param("username") String username); + + /** + * The study, write-locked for the rest of the transaction. Member and group writes take this first, + * so the "is it already a member?" check runs after the competing writer committed and a duplicate + * insert is not attempted at all. Reads must keep using {@code findById}. + */ + @Lock(LockModeType.PESSIMISTIC_WRITE) + @Query("select study from StudyDAO study where study.id = :id") + Optional findByIdForUpdate(@Param("id") UUID id); +} diff --git a/src/main/java/hbp/mip/study/StudyService.java b/src/main/java/hbp/mip/study/StudyService.java new file mode 100644 index 000000000..bdab93c42 --- /dev/null +++ b/src/main/java/hbp/mip/study/StudyService.java @@ -0,0 +1,489 @@ +package hbp.mip.study; + +import hbp.mip.analysis.AnalysisDAO; +import hbp.mip.analysis.AnalysisService; +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDAO; +import hbp.mip.utils.Exceptions.BadRequestException; +import hbp.mip.utils.Exceptions.ConflictException; +import hbp.mip.utils.Exceptions.StudyNotFoundException; +import hbp.mip.utils.Exceptions.AnalysisGroupNotFoundException; +import hbp.mip.utils.Logger; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.security.core.Authentication; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.sql.SQLException; +import java.util.Collection; +import java.util.Comparator; +import java.util.List; +import java.util.Locale; +import java.util.Objects; +import java.util.Optional; +import java.util.UUID; + +/** + * Owns studies and the groups inside them. + * + * Two rules hold everywhere and are the reason this class exists at all: + * + * 1. Everything is scoped to the active user. A study id that is not the caller's is a 404, never a + * 403, so the API never confirms that somebody else's id exists. + * 2. A study holds analysis ids, never analysis copies. Membership is the only thing persisted + * here, so a renamed or re-shared run cannot go stale inside a study. + * + * Name handling mirrors the frontend rules the study chips already enforce (collapse whitespace, + * trim, 60 chars, case-insensitive uniqueness) so moving the store behind this API does not change + * what a user can type. + */ +@Service +public class StudyService { + + static final int MAX_NAME_LENGTH = 60; + + private final ActiveUserService activeUserService; + private final StudyRepository studyRepository; + private final AnalysisService analysisService; + + public StudyService(ActiveUserService activeUserService, + StudyRepository studyRepository, + AnalysisService analysisService) { + this.activeUserService = activeUserService; + this.studyRepository = studyRepository; + this.analysisService = analysisService; + } + + // ------------------------------------------------------------------ studies + + @Transactional(readOnly = true) + public StudiesDTO getStudies(Authentication authentication, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + List studies = studyRepository.findOwnedStudies(user.username()); + logger.debug("Owned studies found: " + studies.size()); + return StudiesDTO.from(studies); + } + + @Transactional(readOnly = true) + public StudyDTO getStudy(Authentication authentication, String studyId, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + return StudyDTO.from(ownedStudy(studyId, user.username(), logger)); + } + + @Transactional + public StudyDTO createStudy(Authentication authentication, CreateStudyDTO request, + Logger logger) { + var user = activeUserService.getActiveUser(authentication); + String name = requireName(request == null ? null : request.name(), "Study name", logger); + + List ownedStudies = studyRepository.findOwnedStudies(user.username()); + rejectDuplicateStudyName(name, ownedStudies, null, logger); + + StudyDAO study = new StudyDAO(new UserDAO(user), name, + nextPosition(ownedStudies.stream().map(StudyDAO::getSortOrder).toList())); + + // "Put this run in a new study" is one gesture in the row menu, so it is one request: a second + // call that fails would otherwise leave an empty study the user never asked for. + String requestedAnalysis = request == null ? null : request.analysisId(); + if (!isBlank(requestedAnalysis)) { + memberFor(study, analysisService.assertAnalysisAccessible(authentication, requestedAnalysis, logger), + logger); + } + + StudyDAO saved = save(study, "A study with that name already exists.", logger); + logger.info("Study created with id: " + saved.getId()); + return StudyDTO.from(saved); + } + + @Transactional + public StudyDTO renameStudy(Authentication authentication, String studyId, + RenameStudyDTO request, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudy(studyId, user.username(), logger); + + String name = requireName(request == null ? null : request.name(), "Study name", logger); + rejectDuplicateStudyName(name, studyRepository.findOwnedStudies(user.username()), study, logger); + + study.setName(name); + + StudyDAO saved = save(study, "A study with that name already exists.", logger); + logger.info("Study renamed. Id: " + study.getId()); + return StudyDTO.from(saved); + } + + /** Deleting a study retires the grouping only. The runs themselves are untouched. */ + @Transactional + public void deleteStudy(Authentication authentication, String studyId, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudy(studyId, user.username(), logger); + + studyRepository.delete(study); + logger.info("Study deleted. Id: " + study.getId()); + } + + // ------------------------------------------------------------------ members + + /** + * Adding a run the study already holds returns the study unchanged: the row menu can toggle blindly. + * + * The study row is locked first, so a second add of the same run waits, then sees the membership and + * returns the study; the member unique constraint is a backstop, not the path that decides this. + */ + @Transactional + public StudyDTO addAnalysis(Authentication authentication, String studyId, + AddStudyMemberDTO request, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudyForUpdate(studyId, user.username(), logger); + + String analysisId = request == null ? null : request.analysisId(); + if (isBlank(analysisId)) { + String errorMessage = "analysisId must be provided."; + logger.warn(errorMessage); + throw new BadRequestException(errorMessage); + } + AnalysisDAO analysis = analysisService.assertAnalysisAccessible(authentication, analysisId.trim(), + logger); + + if (memberOf(study, analysis.getUuid()) != null) { + logger.info("Analysis already belongs to the study. Id: " + analysis.getUuid()); + return StudyDTO.from(study); + } + + memberFor(study, analysis, logger); + + StudyDAO saved = save(study, "That analysis already belongs to this study.", logger); + logger.info("Analysis added to study. Analysis id: " + analysis.getUuid()); + return StudyDTO.from(saved); + } + + /** Leaving the study ends the membership outright: a group cannot keep a run the study lost. */ + @Transactional + public StudyDTO removeAnalysis(Authentication authentication, String studyId, String analysisId, + Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudyForUpdate(studyId, user.username(), logger); + + UUID parsedAnalysisId = parseUuid(analysisId, "analysisId", logger); + StudyMemberDAO member = memberOf(study, parsedAnalysisId); + if (member == null) { + logger.info("Analysis was not a member of the study. Id: " + analysisId); + return StudyDTO.from(study); + } + + study.getMembers().remove(member); + StudyDAO saved = save(study, "That analysis already belongs to this study.", logger); + logger.info("Analysis removed from study. Analysis id: " + analysisId); + return StudyDTO.from(saved); + } + + // ------------------------------------------------------------------ groups + + @Transactional + public StudyDTO createGroup(Authentication authentication, String studyId, + CreateAnalysisGroupDTO request, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudyForUpdate(studyId, user.username(), logger); + + String name = requireName(request == null ? null : request.name(), "Group name", logger); + rejectDuplicateGroupName(name, study, null, logger); + + AnalysisGroupDAO group = new AnalysisGroupDAO(study, name, + nextPosition(study.getGroups().stream().map(AnalysisGroupDAO::getSortOrder).toList())); + study.getGroups().add(group); + + String requestedAnalysis = request == null ? null : request.analysisId(); + if (!isBlank(requestedAnalysis)) { + AnalysisDAO analysis = analysisService.assertAnalysisAccessible(authentication, requestedAnalysis, logger); + joinGroup(study, memberFor(study, analysis, logger), group); + } + + StudyDAO saved = save(study, "An analysis group with that name already exists in this study.", logger); + logger.info("Analysis group created with id: " + group.getId()); + return StudyDTO.from(saved); + } + + @Transactional + public StudyDTO renameGroup(Authentication authentication, String studyId, String groupId, + RenameAnalysisGroupDTO request, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudy(studyId, user.username(), logger); + AnalysisGroupDAO group = ownedGroup(study, groupId, logger); + + String name = requireName(request == null ? null : request.name(), "Group name", logger); + rejectDuplicateGroupName(name, study, group, logger); + + group.setName(name); + + StudyDAO saved = save(study, "An analysis group with that name already exists in this study.", logger); + logger.info("Analysis group renamed. Id: " + group.getId()); + return StudyDTO.from(saved); + } + + /** Deleting a group retires the name, never the runs: its members fall back to ungrouped. */ + @Transactional + public StudyDTO deleteGroup(Authentication authentication, String studyId, String groupId, + Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudyForUpdate(studyId, user.username(), logger); + AnalysisGroupDAO group = ownedGroup(study, groupId, logger); + + // The database would settle this with ON DELETE SET NULL, but the flushed order between the + // group removal and the member updates is not ours to bet on: null them here so the in-memory + // state and the row agree either way. + study.getMembers().stream() + .filter(member -> member.isIn(group)) + .forEach(this::ungroup); + + study.getGroups().remove(group); + StudyDAO saved = save(study, "An analysis group with that name already exists in this study.", logger); + logger.info("Analysis group deleted. Runs were left in the study, ungrouped. Group id: " + groupId); + return StudyDTO.from(saved); + } + + /** + * The strict partition: moving a run in files it nowhere else, so the previous group gives it up by + * itself — one row per (study, analysis) means there is no second row to clean. + * + * A null or blank groupId is the way out of a group that is not "leave the study": the run stays in + * the study and becomes ungrouped. + */ + @Transactional + public StudyDTO updateGroupMembership(Authentication authentication, String studyId, String analysisId, + UpdateAnalysisGroupMembershipDTO request, Logger logger) { + var user = activeUserService.getActiveUser(authentication); + StudyDAO study = ownedStudyForUpdate(studyId, user.username(), logger); + + UUID parsedAnalysisId = parseUuid(analysisId, "analysisId", logger); + StudyMemberDAO existingMember = memberOf(study, parsedAnalysisId); + + String requestedGroupId = request == null ? null : request.groupId(); + if (isBlank(requestedGroupId)) { + if (existingMember == null || (existingMember.getAnalysisGroup() == null + && existingMember.getGroupPosition() == null)) { + logger.info("Analysis is already ungrouped in the study. Id: " + analysisId); + return StudyDTO.from(study); + } + + ungroup(existingMember); + StudyDAO ungrouped = save(study, "That analysis already belongs to this study.", logger); + logger.info("Analysis left its group and stayed in the study. Id: " + analysisId); + return StudyDTO.from(ungrouped); + } + + AnalysisGroupDAO target = ownedGroup(study, requestedGroupId, logger); + StudyMemberDAO member = existingMember != null + ? existingMember + : memberFor(study, analysisService.assertAnalysisAccessible(authentication, analysisId, logger), logger); + + if (member.isIn(target)) { + logger.info("Analysis is already in the requested group. Id: " + analysisId); + return StudyDTO.from(study); + } + + joinGroup(study, member, target); + StudyDAO saved = save(study, "That analysis already belongs to this study.", logger); + logger.info("Analysis moved to group " + target.getId() + ". Analysis id: " + analysisId); + return StudyDTO.from(saved); + } + + // ------------------------------------------------------------------ shared rules + + /** + * A study the caller may touch, or nothing. A study that exists under another owner and a study + * that does not exist answer the same 404, so the API never confirms somebody else's id. + */ + private StudyDAO ownedStudy(String studyId, String username, Logger logger) { + return ownedStudy(studyRepository.findById(parseUuid(studyId, "studyId", logger)), studyId, username, + logger); + } + + /** + * The same study, write-locked for the rest of the transaction. Membership writes take this before + * they look at {@code members}: two concurrent add/move calls on one study then queue on the row + * lock, so the second sees the first's membership and no duplicate row is ever attempted. + * + * The lock itself needs the transaction the service methods already declare. + */ + private StudyDAO ownedStudyForUpdate(String studyId, String username, Logger logger) { + return ownedStudy(studyRepository.findByIdForUpdate(parseUuid(studyId, "studyId", logger)), studyId, + username, logger); + } + + private StudyDAO ownedStudy(Optional candidate, String studyId, String username, + Logger logger) { + StudyDAO study = candidate + .filter(candidateStudy -> candidateStudy.getOwner() != null + && username.equals(candidateStudy.getOwner().getUsername())) + .orElse(null); + + if (study == null) { + var errorMessage = "Study with id : " + studyId + " was not found for the active user."; + logger.warn(errorMessage); + throw new StudyNotFoundException(errorMessage); + } + + return study; + } + + /** + * Writes and flushes in one go, then translates the database's own uniqueness backstop into the + * 409 the caller already got from the pre-check. Two tabs creating the same study name both pass + * the service check; whichever insert loses must hear "conflict", not "internal server error". + * Only unique violations are translated — a NOT NULL or FK failure is still our bug and stays a 500. + */ + private StudyDAO save(StudyDAO study, String duplicateMessage, Logger logger) { + try { + return studyRepository.saveAndFlush(study); + } catch (DataIntegrityViolationException failure) { + if (!isUniqueViolation(failure)) { + throw failure; + } + logger.warn(duplicateMessage); + throw new ConflictException(duplicateMessage); + } + } + + /** PostgreSQL reports unique violations as SQLSTATE 23505; anything else (NOT NULL, FK) stays a 500. */ + private boolean isUniqueViolation(Throwable failure) { + for (Throwable cause = failure; cause != null; cause = cause.getCause()) { + if (cause instanceof SQLException sql) { + return "23505".equals(sql.getSQLState()); + } + } + return false; + } + + private StudyMemberDAO memberOf(StudyDAO study, UUID analysisId) { + return study.getMembers().stream() + .filter(member -> member.getAnalysis() != null + && analysisId.equals(member.getAnalysis().getUuid())) + .findFirst() + .orElse(null); + } + + private AnalysisGroupDAO ownedGroup(StudyDAO study, String groupId, Logger logger) { + UUID parsed = parseUuid(groupId, "groupId", logger); + AnalysisGroupDAO group = study.getGroups().stream() + .filter(candidate -> parsed.equals(candidate.getId())) + .findFirst() + .orElse(null); + if (group == null) { + var errorMessage = "Analysis group with id : " + groupId + " was not found in study : " + study.getId(); + logger.warn(errorMessage); + throw new AnalysisGroupNotFoundException(errorMessage); + } + return group; + } + + /** A group only ever holds study members, so moving in joins the study first when it has to. */ + private StudyMemberDAO memberFor(StudyDAO study, AnalysisDAO analysis, Logger logger) { + StudyMemberDAO member = memberOf(study, analysis.getUuid()); + if (member == null) { + member = new StudyMemberDAO(study, analysis, + nextPosition(studyPositions(study))); + study.getMembers().add(member); + logger.debug("Study membership created while placing the run in a group."); + } + return member; + } + + private void joinGroup(StudyDAO study, StudyMemberDAO member, AnalysisGroupDAO target) { + member.setAnalysisGroup(target); + + // The run being moved is excluded from the max: it cannot count the position it is leaving. + member.setGroupPosition(nextPosition(study.getMembers().stream() + .filter(other -> !Objects.equals(other, member)) + .filter(other -> other.isIn(target)) + .map(StudyMemberDAO::getGroupPosition) + .toList())); + } + + private List studyPositions(StudyDAO study) { + return study.getMembers().stream() + .map(StudyMemberDAO::getStudyPosition) + .toList(); + } + + private void ungroup(StudyMemberDAO member) { + member.setAnalysisGroup(null); + member.setGroupPosition(null); + } + + /** New entries land last, in whichever axis is being appended to: first is 1, then max + 1. */ + private Integer nextPosition(Collection positions) { + return positions.stream() + .filter(Objects::nonNull) + .max(Comparator.naturalOrder()) + .map(last -> last + 1) + .orElse(1); + } + + private String requireName(String rawName, String field, Logger logger) { + String name = normalizeName(rawName); + if (name.isEmpty()) { + String errorMessage = field + " must not be blank."; + logger.warn(errorMessage); + throw new BadRequestException(errorMessage); + } + return name; + } + + /** Whitespace runs collapse to one space, the ends are trimmed, and 60 chars is all that fits. */ + private String normalizeName(String rawName) { + if (rawName == null) { + return ""; + } + String cleaned = rawName.replaceAll("\\s+", " ").trim(); + return cleaned.length() <= MAX_NAME_LENGTH ? cleaned : cleaned.substring(0, MAX_NAME_LENGTH); + } + + /** Comparison key only — the stored name keeps the casing the user typed. */ + private String nameKey(String name) { + return normalizeName(name).toLowerCase(Locale.ROOT); + } + + private void rejectDuplicateStudyName(String name, List ownedStudies, + StudyDAO renamed, Logger logger) { + boolean taken = ownedStudies.stream() + .filter(study -> renamed == null || !study.getId().equals(renamed.getId())) + .anyMatch(study -> nameKey(study.getName()).equals(nameKey(name))); + + if (taken) { + String errorMessage = "A study named '" + name + "' already exists."; + logger.warn(errorMessage); + throw new ConflictException(errorMessage); + } + } + + /** Groups are their own namespace: a group may share its study's name, but not a sibling's. */ + private void rejectDuplicateGroupName(String name, StudyDAO study, AnalysisGroupDAO renamed, + Logger logger) { + boolean taken = study.getGroups().stream() + .filter(group -> renamed == null || !group.getId().equals(renamed.getId())) + .anyMatch(group -> nameKey(group.getName()).equals(nameKey(name))); + + if (taken) { + String errorMessage = "An analysis group named '" + name + "' already exists in this study."; + logger.warn(errorMessage); + throw new ConflictException(errorMessage); + } + } + + private UUID parseUuid(String value, String field, Logger logger) { + if (isBlank(value)) { + String errorMessage = field + " must be provided."; + logger.warn(errorMessage); + throw new BadRequestException(errorMessage); + } + try { + return UUID.fromString(value.trim()); + } catch (IllegalArgumentException e) { + logger.error("Conversion of string to UUID failed: " + e.getMessage()); + throw new BadRequestException("Invalid " + field + ": " + value); + } + } + + private boolean isBlank(String value) { + return value == null || value.trim().isEmpty(); + } +} diff --git a/src/main/java/hbp/mip/study/UpdateAnalysisGroupMembershipDTO.java b/src/main/java/hbp/mip/study/UpdateAnalysisGroupMembershipDTO.java new file mode 100644 index 000000000..380f5a03b --- /dev/null +++ b/src/main/java/hbp/mip/study/UpdateAnalysisGroupMembershipDTO.java @@ -0,0 +1,11 @@ +package hbp.mip.study; + +/** + * Request body of "which group holds this run". + * + * A null or blank groupId means "ungroup": the run stays in the study and leaves its group. One body + * covers both the move and the way out, and the strict partition means a move never needs to name + * the group it leaves. + */ +public record UpdateAnalysisGroupMembershipDTO(String groupId) { +} diff --git a/src/main/java/hbp/mip/user/ActiveUserService.java b/src/main/java/hbp/mip/user/ActiveUserService.java index ecdc09951..9a4c4e630 100644 --- a/src/main/java/hbp/mip/user/ActiveUserService.java +++ b/src/main/java/hbp/mip/user/ActiveUserService.java @@ -114,7 +114,7 @@ public boolean hasAgreedToNDA(Authentication authentication) { return Boolean.TRUE.equals(user.getAgreeNDA()); } - // A username Keycloak gave to someone else must not inherit the previous holder's experiments or accepted terms. + // A username Keycloak gave to someone else must not inherit the previous holder's analyses or accepted terms. private static void refuseAnotherSubject(UserDAO stored, UserDAO authenticated) { if (isKnownSubject(stored) && isKnownSubject(authenticated) && !stored.getSubjectId().equals(authenticated.getSubjectId())) { diff --git a/src/main/java/hbp/mip/utils/ClaimUtils.java b/src/main/java/hbp/mip/utils/ClaimUtils.java index e2de51e72..3ab471588 100644 --- a/src/main/java/hbp/mip/utils/ClaimUtils.java +++ b/src/main/java/hbp/mip/utils/ClaimUtils.java @@ -21,8 +21,8 @@ public class ClaimUtils { @Value("${authentication.all_datasets_allowed_claim}") private String allDatasetsAllowedClaim; - @Value("${authentication.all_experiments_allowed_claim}") - private String allExperimentsAllowedClaim; + @Value("${authentication.all_analyses_allowed_claim}") + private String allAnalysesAllowedClaim; @Value("${authentication.dataset_claim_prefix}") private String datasetClaimPrefix; @@ -46,8 +46,8 @@ private static ArrayList getAuthorityRoles(Authentication authentication } public void validateAccessRightsOnDatasets(Authentication authentication, - List experimentDatasets, Logger logger) { - if (experimentDatasets == null || experimentDatasets.isEmpty()) { + List analysisDatasets, Logger logger) { + if (analysisDatasets == null || analysisDatasets.isEmpty()) { String errorMessage = "At least one dataset must be provided."; logger.warn(errorMessage); throw new BadRequestException(errorMessage); @@ -56,14 +56,14 @@ public void validateAccessRightsOnDatasets(Authentication authentication, ArrayList authorities = getAuthorityRoles(authentication); if (!hasRoleAccess(authorities, allDatasetsAllowedClaim, logger)) { - for (String dataset : experimentDatasets) { + for (String dataset : analysisDatasets) { String datasetRole = getDatasetClaim(dataset); if (!hasRoleAccess(authorities, datasetRole, logger)) { logger.warn("You are not allowed to use dataset: " + dataset); throw new UnauthorizedException("You are not authorized to use these datasets."); } } - logger.debug("User is authorized to use the datasets: " + experimentDatasets); + logger.debug("User is authorized to use the datasets: " + analysisDatasets); } } @@ -91,9 +91,9 @@ public List usableDatasets(Authentication authentication, Logger logger) .toList(); } - public boolean validateAccessRightsOnALLExperiments(Authentication authentication, Logger logger) { + public boolean validateAccessRightsOnALLAnalyses(Authentication authentication, Logger logger) { ArrayList authorities = getAuthorityRoles(authentication); - return hasRoleAccess(authorities, allExperimentsAllowedClaim, logger); + return hasRoleAccess(authorities, allAnalysesAllowedClaim, logger); } public List getAuthorizedDataModels(Logger logger, Authentication authentication, diff --git a/src/main/java/hbp/mip/utils/ControllerExceptionHandler.java b/src/main/java/hbp/mip/utils/ControllerExceptionHandler.java index 16b50a8e7..051674c26 100644 --- a/src/main/java/hbp/mip/utils/ControllerExceptionHandler.java +++ b/src/main/java/hbp/mip/utils/ControllerExceptionHandler.java @@ -1,6 +1,6 @@ package hbp.mip.utils; -import hbp.mip.utils.Exceptions.ExperimentNotFoundException; +import hbp.mip.utils.Exceptions.AnalysisNotFoundException; import hbp.mip.utils.Exceptions.*; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; @@ -17,8 +17,9 @@ public class ControllerExceptionHandler extends ResponseEntityExceptionHandler { public record ErrorMessage (int statusCode, Date timestamp, String message, String description) {} - @ExceptionHandler(ExperimentNotFoundException.class) - public ResponseEntity handleExperimentNotFoundException(ExperimentNotFoundException ex, WebRequest request) { + @ExceptionHandler({AnalysisNotFoundException.class, StudyNotFoundException.class, + AnalysisGroupNotFoundException.class}) + public ResponseEntity handleResourceNotFoundException(RuntimeException ex, WebRequest request) { ErrorMessage message = new ErrorMessage( HttpStatus.NOT_FOUND.value(), new Date(), @@ -51,7 +52,7 @@ public ResponseEntity handleBadRequestException(BadRequestException ex, } // UnauthorizedException means a signed-in user was denied: 403. A 401 would make the portal sign in again. - @ExceptionHandler({UnauthorizedException.class, NoAuthorizedPathologiesException.class, + @ExceptionHandler({UnauthorizedException.class, NoAuthorizedDataModelsException.class, TermsOfUseNotAcceptedException.class, UserIdentityConflictException.class}) public ResponseEntity handleForbiddenException( RuntimeException ex, @@ -66,9 +67,9 @@ public ResponseEntity handleForbiddenException( return new ResponseEntity<>(message, HttpStatus.FORBIDDEN); } - @ExceptionHandler(NoPathologiesAvailableException.class) - public ResponseEntity handleNoPathologiesAvailableException( - NoPathologiesAvailableException ex, + @ExceptionHandler(NoDataModelsAvailableException.class) + public ResponseEntity handleNoDataModelsAvailableException( + NoDataModelsAvailableException ex, WebRequest request ) { ErrorMessage message = new ErrorMessage( diff --git a/src/main/java/hbp/mip/utils/Exceptions/AnalysisGroupNotFoundException.java b/src/main/java/hbp/mip/utils/Exceptions/AnalysisGroupNotFoundException.java new file mode 100644 index 000000000..2d436e439 --- /dev/null +++ b/src/main/java/hbp/mip/utils/Exceptions/AnalysisGroupNotFoundException.java @@ -0,0 +1,7 @@ +package hbp.mip.utils.Exceptions; + +public class AnalysisGroupNotFoundException extends RuntimeException { + public AnalysisGroupNotFoundException(String message) { + super(message); + } +} diff --git a/src/main/java/hbp/mip/utils/Exceptions/AnalysisNotFoundException.java b/src/main/java/hbp/mip/utils/Exceptions/AnalysisNotFoundException.java new file mode 100644 index 000000000..c674d29eb --- /dev/null +++ b/src/main/java/hbp/mip/utils/Exceptions/AnalysisNotFoundException.java @@ -0,0 +1,8 @@ +package hbp.mip.utils.Exceptions; + +public class AnalysisNotFoundException extends RuntimeException { + + public AnalysisNotFoundException(String msg) { + super(msg); + } +} diff --git a/src/main/java/hbp/mip/utils/Exceptions/ConflictException.java b/src/main/java/hbp/mip/utils/Exceptions/ConflictException.java index e87603c8c..442b40c32 100644 --- a/src/main/java/hbp/mip/utils/Exceptions/ConflictException.java +++ b/src/main/java/hbp/mip/utils/Exceptions/ConflictException.java @@ -1,8 +1,8 @@ package hbp.mip.utils.Exceptions; /** - * Thrown when the request is well formed but collides with an existing resource, such as a folder or - * set name already taken in the same namespace. Mapped to 409. + * Thrown when the request is well formed but collides with an existing resource, such as a Study or + * Analysis Group name already taken in the same namespace. Mapped to 409. */ public class ConflictException extends RuntimeException { diff --git a/src/main/java/hbp/mip/utils/Exceptions/ExperimentNotFoundException.java b/src/main/java/hbp/mip/utils/Exceptions/ExperimentNotFoundException.java deleted file mode 100644 index cfec9a6ed..000000000 --- a/src/main/java/hbp/mip/utils/Exceptions/ExperimentNotFoundException.java +++ /dev/null @@ -1,8 +0,0 @@ -package hbp.mip.utils.Exceptions; - -public class ExperimentNotFoundException extends RuntimeException { - - public ExperimentNotFoundException(String msg) { - super(msg); - } -} diff --git a/src/main/java/hbp/mip/utils/Exceptions/NoAuthorizedDataModelsException.java b/src/main/java/hbp/mip/utils/Exceptions/NoAuthorizedDataModelsException.java new file mode 100644 index 000000000..99a9fd928 --- /dev/null +++ b/src/main/java/hbp/mip/utils/Exceptions/NoAuthorizedDataModelsException.java @@ -0,0 +1,8 @@ +package hbp.mip.utils.Exceptions; + +public class NoAuthorizedDataModelsException extends RuntimeException { + + public NoAuthorizedDataModelsException(String msg) { + super(msg); + } +} diff --git a/src/main/java/hbp/mip/utils/Exceptions/NoAuthorizedPathologiesException.java b/src/main/java/hbp/mip/utils/Exceptions/NoAuthorizedPathologiesException.java deleted file mode 100644 index 34f766392..000000000 --- a/src/main/java/hbp/mip/utils/Exceptions/NoAuthorizedPathologiesException.java +++ /dev/null @@ -1,8 +0,0 @@ -package hbp.mip.utils.Exceptions; - -public class NoAuthorizedPathologiesException extends RuntimeException { - - public NoAuthorizedPathologiesException(String msg) { - super(msg); - } -} diff --git a/src/main/java/hbp/mip/utils/Exceptions/NoDataModelsAvailableException.java b/src/main/java/hbp/mip/utils/Exceptions/NoDataModelsAvailableException.java new file mode 100644 index 000000000..79a15f9a9 --- /dev/null +++ b/src/main/java/hbp/mip/utils/Exceptions/NoDataModelsAvailableException.java @@ -0,0 +1,8 @@ +package hbp.mip.utils.Exceptions; + +public class NoDataModelsAvailableException extends RuntimeException { + + public NoDataModelsAvailableException(String msg) { + super(msg); + } +} diff --git a/src/main/java/hbp/mip/utils/Exceptions/NoPathologiesAvailableException.java b/src/main/java/hbp/mip/utils/Exceptions/NoPathologiesAvailableException.java deleted file mode 100644 index 77c18a988..000000000 --- a/src/main/java/hbp/mip/utils/Exceptions/NoPathologiesAvailableException.java +++ /dev/null @@ -1,8 +0,0 @@ -package hbp.mip.utils.Exceptions; - -public class NoPathologiesAvailableException extends RuntimeException { - - public NoPathologiesAvailableException(String msg) { - super(msg); - } -} diff --git a/src/main/java/hbp/mip/utils/Exceptions/StudyNotFoundException.java b/src/main/java/hbp/mip/utils/Exceptions/StudyNotFoundException.java new file mode 100644 index 000000000..532908e75 --- /dev/null +++ b/src/main/java/hbp/mip/utils/Exceptions/StudyNotFoundException.java @@ -0,0 +1,7 @@ +package hbp.mip.utils.Exceptions; + +public class StudyNotFoundException extends RuntimeException { + public StudyNotFoundException(String message) { + super(message); + } +} diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml index b12cb4c24..b0ba7aad1 100644 --- a/src/main/resources/application.yml +++ b/src/main/resources/application.yml @@ -59,7 +59,7 @@ spring: authentication: enabled: ${AUTHENTICATION:1} all_datasets_allowed_claim: research_dataset_all - all_experiments_allowed_claim: research_experiment_all + all_analyses_allowed_claim: research_experiment_all dataset_claim_prefix: research_dataset_ # Public Keycloak client (device flow) for `mip login` on users' own computers; empty = not offered. cli_client_id: ${KEYCLOAK_CLI_CLIENT_ID:} @@ -91,10 +91,10 @@ services: frontend: base-url: ${PLATFORM_UI_BASE_URL:http://localhost:4200} -### EXPERIMENTS ### -experiments: - # How long an unsaved studio run stays available to "Save experiment" without re-running it. - run-draft-ttl: ${EXPERIMENT_RUN_DRAFT_TTL:PT24H} +### ANALYSES ### +analyses: + # How long an unsaved studio run stays available to "Save analysis" without re-running it. + run-draft-ttl: ${ANALYSIS_RUN_DRAFT_TTL:PT24H} ### PLATFORM VERSION ### mip: diff --git a/src/main/resources/db/migration/V6__AnalysisStudyTerminology.sql b/src/main/resources/db/migration/V6__AnalysisStudyTerminology.sql new file mode 100644 index 000000000..9cb5c7cda --- /dev/null +++ b/src/main/resources/db/migration/V6__AnalysisStudyTerminology.sql @@ -0,0 +1,65 @@ +-- Structural renames only: stored request/result text and identifiers are never rewritten. +ALTER TABLE experiment RENAME TO analysis; +ALTER TABLE experiment_run RENAME TO analysis_run; +ALTER TABLE experiment_folder RENAME TO study; +ALTER TABLE experiment_set RENAME TO analysis_group; +ALTER TABLE experiment_folder_member RENAME TO study_member; + +ALTER TABLE analysis RENAME COLUMN analysis TO analysis_request; +ALTER TABLE analysis_run RENAME COLUMN analysis TO analysis_request; +ALTER TABLE analysis_group RENAME COLUMN folder_id TO study_id; +ALTER TABLE study_member RENAME COLUMN folder_id TO study_id; +ALTER TABLE study_member RENAME COLUMN experiment_uuid TO analysis_id; +ALTER TABLE study_member RENAME COLUMN set_id TO group_id; +ALTER TABLE study_member RENAME COLUMN folder_position TO study_position; +ALTER TABLE study_member RENAME COLUMN set_position TO group_position; + +-- Renaming a primary-key/unique constraint also renames its backing index. +ALTER TABLE analysis RENAME CONSTRAINT experiment_pkey TO analysis_pkey; +ALTER TABLE analysis RENAME CONSTRAINT experiment_status_check TO analysis_status_check; +ALTER TABLE analysis RENAME CONSTRAINT experiment_created_by_username_fkey TO analysis_created_by_username_fkey; +ALTER TABLE analysis_run RENAME CONSTRAINT experiment_run_pkey TO analysis_run_pkey; +ALTER TABLE analysis_run RENAME CONSTRAINT experiment_run_created_by_username_fkey TO analysis_run_created_by_username_fkey; +ALTER TABLE study RENAME CONSTRAINT experiment_folder_pkey TO study_pkey; +ALTER TABLE study RENAME CONSTRAINT experiment_folder_owner_username_fkey TO study_owner_username_fkey; +ALTER TABLE analysis_group RENAME CONSTRAINT experiment_set_pkey TO analysis_group_pkey; +ALTER TABLE analysis_group RENAME CONSTRAINT experiment_set_folder_id_fkey TO analysis_group_study_id_fkey; +ALTER TABLE study_member RENAME CONSTRAINT experiment_folder_member_pkey TO study_member_pkey; +ALTER TABLE study_member RENAME CONSTRAINT experiment_folder_member_folder_id_fkey TO study_member_study_id_fkey; +ALTER TABLE study_member RENAME CONSTRAINT experiment_folder_member_experiment_uuid_fkey TO study_member_analysis_id_fkey; +ALTER TABLE study_member RENAME CONSTRAINT experiment_folder_member_set_id_fkey TO study_member_group_id_fkey; +ALTER TABLE study_member RENAME CONSTRAINT uq_experiment_folder_member TO uq_study_member; + +ALTER INDEX uq_experiment_folder_owner_name RENAME TO uq_study_owner_name; +ALTER INDEX uq_experiment_set_folder_name RENAME TO uq_analysis_group_study_name; +ALTER INDEX idx_experiment_folder_member_set RENAME TO idx_study_member_group; +ALTER INDEX idx_experiment_folder_member_experiment RENAME TO idx_study_member_analysis; +ALTER INDEX idx_experiment_run_created RENAME TO idx_analysis_run_created; + +-- Identical to the shipped V5 rule, including fail-closed handling of malformed requests. +CREATE FUNCTION analysis_datasets_readable(analysis_request TEXT, allowed TEXT) RETURNS BOOLEAN AS $$ +DECLARE + input JSONB; + validation JSONB; +BEGIN + input := analysis_request::jsonb -> 'inputdata'; + IF jsonb_typeof(input -> 'datasets') IS DISTINCT FROM 'array' OR jsonb_array_length(input -> 'datasets') = 0 THEN + RETURN FALSE; + END IF; + + validation := COALESCE(NULLIF(input -> 'validation_datasets', 'null'::jsonb), '[]'::jsonb); + IF jsonb_typeof(validation) <> 'array' THEN + RETURN FALSE; + END IF; + + RETURN NOT EXISTS ( + SELECT 1 + FROM jsonb_array_elements_text((input -> 'datasets') || validation) AS dataset + WHERE (allowed::jsonb ? lower(dataset)) IS NOT TRUE); +EXCEPTION + WHEN data_exception THEN + RETURN FALSE; +END; +$$ LANGUAGE plpgsql STABLE; + +DROP FUNCTION experiment_datasets_readable(TEXT, TEXT); diff --git a/src/test/java/hbp/mip/algorithm/AnalysisExecutionServiceContractTest.java b/src/test/java/hbp/mip/algorithm/AnalysisExecutionServiceContractTest.java new file mode 100644 index 000000000..5be23d49a --- /dev/null +++ b/src/test/java/hbp/mip/algorithm/AnalysisExecutionServiceContractTest.java @@ -0,0 +1,47 @@ +package hbp.mip.algorithm; + +import com.google.gson.JsonParser; +import hbp.mip.utils.HTTPUtil; +import hbp.mip.utils.JsonConverters; +import hbp.mip.utils.Logger; +import hbp.mip.utils.RawJson; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.Map; +import java.util.UUID; +import java.util.concurrent.atomic.AtomicReference; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.mockStatic; + +class AnalysisExecutionServiceContractTest { + @Test + void exaflowStillReceivesTheUnwrappedRequestWithTheExecutionId() { + var request = new AnalysisRequestDTO("original-request-id", + new AnalysisRequestDTO.AnalysisInputDataDTO("dm:1", List.of("ds1"), List.of("validation"), + Map.of("condition", "AND"), List.of("age")), + List.of(new AnalysisRequestDTO.AnalysisPreprocessingStepDTO("scale", Map.of("method", "standard"))), + new AnalysisRequestDTO.AnalysisAlgorithmDTO("histogram", List.of("age"), null, Map.of("bins", 10)), + Map.of("option", true)); + var executionId = UUID.randomUUID(); + var sent = new AtomicReference(); + String result = "{\"n_obs\":217,\"p\":null}"; + try (var http = mockStatic(HTTPUtil.class)) { + http.when(() -> HTTPUtil.sendPost(eq("http://exaflow/analysis"), isNull(), anyString(), any())) + .thenAnswer(call -> { + sent.set(call.getArgument(2)); + call.getArgument(3).append(result); + return 200; + }); + var response = new AnalysisExecutionService("http://exaflow/analysis") + .runAnalysis(executionId, request, new Logger("user", "test")); + var expected = JsonParser.parseString(JsonConverters.convertObjectToJsonString(request)).getAsJsonObject(); + expected.addProperty("request_id", executionId.toString()); + assertThat(JsonParser.parseString(sent.get())).isEqualTo(expected); + assertThat(response.body()).isEqualTo(new RawJson(result)); + assertThat(request.request_id()).isEqualTo("original-request-id"); + } + } +} diff --git a/src/test/java/hbp/mip/algorithm/AnalysisServiceRequestIdTest.java b/src/test/java/hbp/mip/algorithm/AnalysisExecutionServiceRequestIdTest.java similarity index 71% rename from src/test/java/hbp/mip/algorithm/AnalysisServiceRequestIdTest.java rename to src/test/java/hbp/mip/algorithm/AnalysisExecutionServiceRequestIdTest.java index 6d4479b66..f7b4b5e85 100644 --- a/src/test/java/hbp/mip/algorithm/AnalysisServiceRequestIdTest.java +++ b/src/test/java/hbp/mip/algorithm/AnalysisExecutionServiceRequestIdTest.java @@ -10,7 +10,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatThrownBy; -class AnalysisServiceRequestIdTest { +class AnalysisExecutionServiceRequestIdTest { @Test void requireRunnable_rejectsMissingAlgorithmAndInputdataAsBadRequest() { @@ -18,15 +18,15 @@ void requireRunnable_rejectsMissingAlgorithmAndInputdataAsBadRequest() { var algorithm = new AnalysisRequestDTO.AnalysisAlgorithmDTO("histogram", null, List.of("age"), Map.of()); var logger = new Logger("user", "test"); - assertThatThrownBy(() -> AnalysisService.requireRunnable(null, logger)) - .isInstanceOf(BadRequestException.class).hasMessageContaining("analysis"); - assertThatThrownBy(() -> AnalysisService.requireRunnable( + assertThatThrownBy(() -> AnalysisExecutionService.requireRunnable(null, logger)) + .isInstanceOf(BadRequestException.class).hasMessageContaining("analysisRequest"); + assertThatThrownBy(() -> AnalysisExecutionService.requireRunnable( new AnalysisRequestDTO(null, inputdata, null, null, null), logger)) .isInstanceOf(BadRequestException.class).hasMessageContaining("algorithm.name"); - assertThatThrownBy(() -> AnalysisService.requireRunnable( + assertThatThrownBy(() -> AnalysisExecutionService.requireRunnable( new AnalysisRequestDTO(null, null, null, algorithm, null), logger)) .isInstanceOf(BadRequestException.class).hasMessageContaining("inputdata"); - AnalysisService.requireRunnable(new AnalysisRequestDTO(null, inputdata, null, algorithm, null), logger); + AnalysisExecutionService.requireRunnable(new AnalysisRequestDTO(null, inputdata, null, algorithm, null), logger); } @Test @@ -41,15 +41,15 @@ void allDatasets_coversValidationDatasetsForAccessChecks() { void convertResponse_mapsExaflowBusyToRetryMessage() { var exaflowBody = new StringBuilder("The controller is already running the maximum number of concurrent analyses."); - assertThat(AnalysisService.convertResponseToAnalysisResult(new Logger("user", "test"), 503, exaflowBody)) - .isEqualTo(Map.of("data", AnalysisService.BUSY_ERROR_MESSAGE, "type", "text/plain+error")); + assertThat(AnalysisExecutionService.convertResponseToAnalysisResult(new Logger("user", "test"), 503, exaflowBody)) + .isEqualTo(Map.of("data", AnalysisExecutionService.BUSY_ERROR_MESSAGE, "type", "text/plain+error")); } @Test void convertResponse_passesExaflowMessageTooLargeThrough() { var exaflowBody = new StringBuilder("result too large (>104857600 bytes / 100.0 MiB); reduce variables/levels"); - assertThat(AnalysisService.convertResponseToAnalysisResult(new Logger("user", "test"), 413, exaflowBody)) + assertThat(AnalysisExecutionService.convertResponseToAnalysisResult(new Logger("user", "test"), 413, exaflowBody)) .isEqualTo(Map.of("data", exaflowBody.toString(), "type", "text/plain+error")); } @@ -57,7 +57,7 @@ void convertResponse_passesExaflowMessageTooLargeThrough() { void convertResponse_passesExaflowMalformedRequestThrough() { var exaflowBody = new StringBuilder("Request malformed:\nbody.inputdata: Field required"); - assertThat(AnalysisService.convertResponseToAnalysisResult(new Logger("user", "test"), 422, exaflowBody)) + assertThat(AnalysisExecutionService.convertResponseToAnalysisResult(new Logger("user", "test"), 422, exaflowBody)) .isEqualTo(Map.of("data", exaflowBody.toString(), "type", "text/plain+error")); } } diff --git a/src/test/java/hbp/mip/algorithm/AnalysisRequestDTODeserializationTest.java b/src/test/java/hbp/mip/algorithm/AnalysisRequestDTODeserializationTest.java index bdb6d9bef..378622be9 100644 --- a/src/test/java/hbp/mip/algorithm/AnalysisRequestDTODeserializationTest.java +++ b/src/test/java/hbp/mip/algorithm/AnalysisRequestDTODeserializationTest.java @@ -1,7 +1,7 @@ package hbp.mip.algorithm; import com.fasterxml.jackson.databind.ObjectMapper; -import hbp.mip.experiment.ExperimentExecutionDTO; +import hbp.mip.analysis.AnalysisExecutionDTO; import hbp.mip.utils.JsonConverters; import org.junit.jupiter.api.Test; @@ -29,22 +29,22 @@ class AnalysisRequestDTODeserializationTest { """; @Test - void jacksonReadsAnalysisFromExperimentExecutionBody() throws Exception { - String body = "{\"name\":\"experiment\",\"analysis\":" + ANALYSIS_JSON + "}"; + void jacksonReadsAnalysisRequestFromExecutionBody() throws Exception { + String body = "{\"name\":\"analysis\",\"analysisRequest\":" + ANALYSIS_JSON + "}"; - ExperimentExecutionDTO execution = new ObjectMapper().readValue(body, ExperimentExecutionDTO.class); + AnalysisExecutionDTO execution = new ObjectMapper().readValue(body, AnalysisExecutionDTO.class); - assertThat(execution.analysis().algorithm().name()).isEqualTo("histogram"); - assertThat(execution.analysis().inputdata().datasets()).containsExactly("ds1"); - assertThat(execution.analysis().preprocessing()).extracting("name").containsExactly("winsorize"); + assertThat(execution.analysisRequest().algorithm().name()).isEqualTo("histogram"); + assertThat(execution.analysisRequest().inputdata().datasets()).containsExactly("ds1"); + assertThat(execution.analysisRequest().preprocessing()).extracting("name").containsExactly("winsorize"); } @Test - void gsonReadsAnalysisFromStoredExperimentJson() { - AnalysisRequestDTO analysis = JsonConverters.convertJsonStringToObject(ANALYSIS_JSON, AnalysisRequestDTO.class); + void gsonReadsAnalysisFromStoredAnalysisJson() { + AnalysisRequestDTO analysisRequest = JsonConverters.convertJsonStringToObject(ANALYSIS_JSON, AnalysisRequestDTO.class); - assertThat(analysis.algorithm().name()).isEqualTo("histogram"); - assertThat(analysis.inputdata().variables()).containsExactly("age"); - assertThat(analysis.preprocessing()).extracting("name").containsExactly("winsorize"); + assertThat(analysisRequest.algorithm().name()).isEqualTo("histogram"); + assertThat(analysisRequest.inputdata().variables()).containsExactly("age"); + assertThat(analysisRequest.preprocessing()).extracting("name").containsExactly("winsorize"); } } diff --git a/src/test/java/hbp/mip/analysis/AnalysisAPITest.java b/src/test/java/hbp/mip/analysis/AnalysisAPITest.java new file mode 100644 index 000000000..53922a499 --- /dev/null +++ b/src/test/java/hbp/mip/analysis/AnalysisAPITest.java @@ -0,0 +1,138 @@ +package hbp.mip.analysis; + +import hbp.mip.algorithm.AnalysisRequestDTO; +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.ControllerExceptionHandler; +import hbp.mip.utils.Exceptions.BadRequestException; +import hbp.mip.utils.Exceptions.NoContent; +import hbp.mip.utils.Logger; +import hbp.mip.utils.RawJson; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; + +@ExtendWith(MockitoExtension.class) +class AnalysisAPITest { + private static final UUID ID = UUID.fromString("33333333-3333-3333-3333-333333333333"); + private static final UserDTO USER = new UserDTO("user", "User", "user@example.org", "subject", true); + private static final String EXECUTION = """ + {"name":"My analysis","analysisRequest":{"inputdata":{"data_model":"dm:1","datasets":["ds1"], + "variables":["age"]},"algorithm":{"name":"histogram","x":["age"],"parameters":{}}}} + """; + + @Mock private AnalysisService service; + @Mock private ActiveUserService activeUserService; + private final Authentication principal = new UsernamePasswordAuthenticationToken("user", null); + private MockMvc mvc; + + @BeforeEach + void setUp() { + mvc = MockMvcBuilders.standaloneSetup(new AnalysisAPI(service, activeUserService)) + .setControllerAdvice(new ControllerExceptionHandler()).build(); + lenient().when(activeUserService.getActiveUser(any())).thenReturn(USER); + } + + @Test + void obsoleteRoutesAreUnavailableAndOnlyRenamedFieldsAreReturned() throws Exception { + mvc.perform(get("/experiments").principal(principal)).andExpect(status().isNotFound()); + mvc.perform(post("/experiments/runs").principal(principal).contentType("application/json").content(EXECUTION)) + .andExpect(status().isNotFound()); + when(service.getAnalysis(any(), eq(ID.toString()), any())).thenReturn(response()); + mvc.perform(get("/analyses/" + ID).principal(principal)).andExpect(status().isOk()) + .andExpect(jsonPath("$.analysisRequest.algorithm.name").value("histogram")) + .andExpect(jsonPath("$.analysis").doesNotExist()) + .andExpect(jsonPath("$.algorithm").doesNotExist()); + } + + @Test + void listIncludesCollectionPaginationAndTotals() throws Exception { + when(service.getAnalyses(any(), isNull(), isNull(), isNull(), isNull(), eq(true), eq(false), + eq(false), eq(0), eq(10), eq("created"), eq(true), any())) + .thenReturn(new AnalysesDTO(List.of(response()), 0, 3, 21L)); + mvc.perform(get("/analyses").principal(principal)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.analyses[0].uuid").value(ID.toString())) + .andExpect(jsonPath("$.analyses[0].analysisRequest.algorithm.name").value("histogram")) + .andExpect(jsonPath("$.currentPage").value(0)) + .andExpect(jsonPath("$.totalPages").value(3)) + .andExpect(jsonPath("$.totalAnalyses").value(21)); + } + + @Test + void emptyListRemainsNoContent() throws Exception { + when(service.getAnalyses(any(), any(), any(), any(), any(), anyBoolean(), anyBoolean(), + anyBoolean(), anyInt(), anyInt(), anyString(), anyBoolean(), any())).thenThrow(new NoContent("Empty")); + mvc.perform(get("/analyses").principal(principal)).andExpect(status().isNoContent()); + } + + @Test + void previewMapsTheWholeExecutionRequestAndReturnsRawResults() throws Exception { + when(service.previewAnalysis(any(), any(), any())).thenReturn(response()); + mvc.perform(post("/analyses/preview").principal(principal).contentType("application/json").content(EXECUTION)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.analysisRequest.inputdata.variables[0]").value("age")) + .andExpect(jsonPath("$.result.n_obs").value(217)) + .andExpect(jsonPath("$.result.p").value(org.hamcrest.Matchers.nullValue())) + .andExpect(jsonPath("$.status").value("success")); + var execution = ArgumentCaptor.forClass(AnalysisExecutionDTO.class); + verify(service).previewAnalysis(eq(principal), execution.capture(), any(Logger.class)); + assertThat(execution.getValue().analysisRequest().algorithm().name()).isEqualTo("histogram"); + } + + @Test + void runReturnsTheRunIdAndSaveAcceptsOnlyItsReferenceAndName() throws Exception { + when(service.runAnalysis(any(), eq(USER), any(), any())).thenReturn(response()); + mvc.perform(post("/analyses/runs").principal(principal).contentType("application/json").content(EXECUTION)) + .andExpect(status().isOk()).andExpect(jsonPath("$.uuid").value(ID.toString())); + when(service.saveAnalysisRun(eq(USER), eq(ID.toString()), eq("Saved"), any())).thenReturn(response()); + mvc.perform(post("/analyses").principal(principal).contentType("application/json") + .content("{\"runId\":\"" + ID + "\",\"name\":\"Saved\"}")) + .andExpect(status().isCreated()).andExpect(jsonPath("$.uuid").value(ID.toString())); + verify(service).saveAnalysisRun(eq(USER), eq(ID.toString()), eq("Saved"), any()); + } + + @Test + void detailPatchAndDeleteKeepTheirStatusCodes() throws Exception { + when(service.getAnalysis(any(), eq(ID.toString()), any())).thenReturn(response()); + mvc.perform(get("/analyses/" + ID).principal(principal)) + .andExpect(status().isOk()).andExpect(jsonPath("$.analysisRequest.algorithm.name").value("histogram")); + when(service.updateAnalysis(eq(USER), eq(ID.toString()), any(), any())).thenReturn(response()); + mvc.perform(patch("/analyses/" + ID).principal(principal).contentType("application/json") + .content("{\"name\":\"Renamed\",\"shared\":true}")) + .andExpect(status().isOk()); + mvc.perform(delete("/analyses/" + ID).principal(principal)).andExpect(status().isOk()); + verify(service).deleteAnalysis(eq(USER), eq(ID.toString()), any()); + } + + @Test + void validationFailureIsABadRequest() throws Exception { + when(service.previewAnalysis(any(), any(), any())).thenThrow(new BadRequestException("Missing required analysisRequest.")); + mvc.perform(post("/analyses/preview").principal(principal).contentType("application/json").content("{}")) + .andExpect(status().isBadRequest()).andExpect(jsonPath("$.statusCode").value(400)); + } + + private static AnalysisDTO response() { + var analysisRequest = new AnalysisRequestDTO(null, + new AnalysisRequestDTO.AnalysisInputDataDTO("dm:1", List.of("ds1"), null, null, List.of("age")), + null, new AnalysisRequestDTO.AnalysisAlgorithmDTO("histogram", List.of("age"), null, null), null); + return new AnalysisDTO(ID, "My analysis", USER, null, null, null, true, false, + new RawJson("{\"n_obs\":217,\"p\":null}"), AnalysisDAO.Status.success, analysisRequest, "9.0.0"); + } +} diff --git a/src/test/java/hbp/mip/experiment/ExperimentDTOResultTest.java b/src/test/java/hbp/mip/analysis/AnalysisDTOResultTest.java similarity index 66% rename from src/test/java/hbp/mip/experiment/ExperimentDTOResultTest.java rename to src/test/java/hbp/mip/analysis/AnalysisDTOResultTest.java index b94f2876b..73412d0d9 100644 --- a/src/test/java/hbp/mip/experiment/ExperimentDTOResultTest.java +++ b/src/test/java/hbp/mip/analysis/AnalysisDTOResultTest.java @@ -1,4 +1,4 @@ -package hbp.mip.experiment; +package hbp.mip.analysis; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; @@ -8,16 +8,16 @@ import static org.assertj.core.api.Assertions.assertThat; -class ExperimentDTOResultTest { +class AnalysisDTOResultTest { @Test void servesTheStoredResultAsExaflowSentIt() throws Exception { - ExperimentDAO experiment = new ExperimentDAO(); - experiment.setCreatedBy(new UserDAO("user", "User", "user@example.org", "sub")); - experiment.setResult("{\"n_obs\":217,\"p\":null,\"table\":{\"se\":null}}"); + AnalysisDAO analysis = new AnalysisDAO(); + analysis.setCreatedBy(new UserDAO("user", "User", "user@example.org", "sub")); + analysis.setResult("{\"n_obs\":217,\"p\":null,\"table\":{\"se\":null}}"); JsonNode result = new ObjectMapper() - .readTree(SpringJsonMapper.INSTANCE.writeValueAsString(new ExperimentDTO(experiment, true))) + .readTree(SpringJsonMapper.INSTANCE.writeValueAsString(new AnalysisDTO(analysis, true))) .get("result"); assertThat(result.get("n_obs").isIntegralNumber()).isTrue(); diff --git a/src/test/java/hbp/mip/experiment/ExperimentServiceMipVersionTest.java b/src/test/java/hbp/mip/analysis/AnalysisServiceMipVersionTest.java similarity index 60% rename from src/test/java/hbp/mip/experiment/ExperimentServiceMipVersionTest.java rename to src/test/java/hbp/mip/analysis/AnalysisServiceMipVersionTest.java index 1024a9c96..f085c3475 100644 --- a/src/test/java/hbp/mip/experiment/ExperimentServiceMipVersionTest.java +++ b/src/test/java/hbp/mip/analysis/AnalysisServiceMipVersionTest.java @@ -1,7 +1,7 @@ -package hbp.mip.experiment; +package hbp.mip.analysis; import hbp.mip.algorithm.AnalysisRequestDTO; -import hbp.mip.algorithm.AnalysisService; +import hbp.mip.algorithm.AnalysisExecutionService; import hbp.mip.user.ActiveUserService; import hbp.mip.utils.ClaimUtils; import hbp.mip.utils.Logger; @@ -23,7 +23,7 @@ import static org.mockito.Mockito.when; @ExtendWith(MockitoExtension.class) -class ExperimentServiceMipVersionTest { +class AnalysisServiceMipVersionTest { @Mock private ActiveUserService activeUserService; @@ -32,39 +32,39 @@ class ExperimentServiceMipVersionTest { private ClaimUtils claimUtils; @Mock - private ExperimentRepository experimentRepository; + private AnalysisRepository analysisRepository; @Mock - private ExperimentRunRepository experimentRunRepository; + private AnalysisRunRepository analysisRunRepository; @Mock - private AnalysisService analysisService; + private AnalysisExecutionService analysisExecutionService; @Mock private Authentication authentication; - private ExperimentService experimentService; + private AnalysisService analysisService; @BeforeEach void setUp() { - experimentService = new ExperimentService(activeUserService, claimUtils, experimentRepository, - experimentRunRepository, analysisService, false, "9.0.0", Duration.ofHours(24)); + analysisService = new AnalysisService(activeUserService, claimUtils, analysisRepository, + analysisRunRepository, analysisExecutionService, false, "9.0.0", Duration.ofHours(24)); } @Test - void previewExperiment_returnsMipVersionFromEnvironment() { + void previewAnalysis_returnsMipVersionFromEnvironment() { var execution = sampleExecution(); - when(analysisService.runAnalysis(any(UUID.class), eq(execution.analysis()), any(Logger.class))) - .thenReturn(new AnalysisService.AnalysisResultDTO(200, Map.of("ok", true))); + when(analysisExecutionService.runAnalysis(any(UUID.class), eq(execution.analysisRequest()), any(Logger.class))) + .thenReturn(new AnalysisExecutionService.AnalysisResultDTO(200, Map.of("ok", true))); - var response = experimentService.previewExperiment(authentication, execution, new Logger("user", "test")); + var response = analysisService.previewAnalysis(authentication, execution, new Logger("user", "test")); assertThat(response.mipVersion()).isEqualTo("9.0.0"); } - private ExperimentExecutionDTO sampleExecution() { - var analysis = new AnalysisRequestDTO( + private AnalysisExecutionDTO sampleExecution() { + var analysisRequest = new AnalysisRequestDTO( null, new AnalysisRequestDTO.AnalysisInputDataDTO( "dm:1", @@ -79,6 +79,6 @@ private ExperimentExecutionDTO sampleExecution() { List.of("age"), Map.of()), null); - return new ExperimentExecutionDTO("test experiment", analysis); + return new AnalysisExecutionDTO("test analysis", analysisRequest); } } diff --git a/src/test/java/hbp/mip/analysis/AnalysisServiceRunSaveTest.java b/src/test/java/hbp/mip/analysis/AnalysisServiceRunSaveTest.java new file mode 100644 index 000000000..0c025865b --- /dev/null +++ b/src/test/java/hbp/mip/analysis/AnalysisServiceRunSaveTest.java @@ -0,0 +1,281 @@ +package hbp.mip.analysis; + +import hbp.mip.algorithm.AnalysisRequestDTO; +import hbp.mip.algorithm.AnalysisExecutionService; +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.ClaimUtils; +import hbp.mip.utils.Exceptions.BadRequestException; +import hbp.mip.utils.Exceptions.AnalysisNotFoundException; +import hbp.mip.utils.JsonConverters; +import hbp.mip.utils.Logger; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.security.core.Authentication; + +import java.time.Duration; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.verifyNoInteractions; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +class AnalysisServiceRunSaveTest { + + private static final UserDTO USER = new UserDTO("user", "User", "user@example.org", "subject", true); + + @Mock + private ActiveUserService activeUserService; + + @Mock + private ClaimUtils claimUtils; + + @Mock + private AnalysisRepository analysisRepository; + + @Mock + private AnalysisRunRepository analysisRunRepository; + + @Mock + private AnalysisExecutionService analysisExecutionService; + + @Mock + private Authentication authentication; + + private final Logger logger = new Logger("user", "test"); + + private AnalysisService analysisService; + + @BeforeEach + void setUp() { + analysisService = service(false); + } + + @Test + void analysisRequestRemainsImmutableWhenUpdatingARecord() { + var id = UUID.randomUUID().toString(); + when(analysisRepository.loadAnalysis(eq(id), any())).thenReturn(new AnalysisDAO()); + var patch = new AnalysisDTO(null, null, null, null, null, null, null, null, null, null, + sampleExecution().analysisRequest(), null); + + assertThatThrownBy(() -> analysisService.updateAnalysis(USER, id, patch, logger)) + .isInstanceOf(BadRequestException.class).hasMessageContaining("analysisRequest"); + verify(analysisRepository, never()).save(any()); + } + + @Test + void previewDoesNotPersistAnything() { + var execution = sampleExecution(); + when(analysisExecutionService.runAnalysis(any(UUID.class), eq(execution.analysisRequest()), any(Logger.class))) + .thenReturn(new AnalysisExecutionService.AnalysisResultDTO(200, Map.of("ok", true))); + + analysisService.previewAnalysis(authentication, execution, logger); + + verifyNoInteractions(analysisRunRepository, analysisRepository); + } + + @Test + void theSameRunCanBeSavedMoreThanOnceWithoutBeingConsumed() { + var run = keptRun("user", hoursAgo(1)); + when(analysisRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); + when(analysisRepository.createAnalysisFromRun(any(), anyString(), any(), any())).thenCallRealMethod(); + + var first = analysisService.saveAnalysisRun(USER, run.getUuid().toString(), "First", logger); + var second = analysisService.saveAnalysisRun(USER, run.getUuid().toString(), "Second", logger); + + assertThat(first.uuid()).isNotEqualTo(second.uuid()).isNotEqualTo(run.getUuid()); + verify(analysisRunRepository, org.mockito.Mockito.times(2)).findById(run.getUuid()); + verifyNoInteractions(analysisExecutionService); + } + + @Test + void runAnalysis_keepsSuccessfulRunForSaving() { + var execution = sampleExecution(); + when(analysisExecutionService.runAnalysis(any(UUID.class), eq(execution.analysisRequest()), any(Logger.class))) + .thenReturn(new AnalysisExecutionService.AnalysisResultDTO(200, Map.of("ok", true))); + + var response = analysisService.runAnalysis(authentication, USER, execution, logger); + + var kept = ArgumentCaptor.forClass(AnalysisRunDAO.class); + verify(analysisRunRepository).deleteCreatedBefore(any(Date.class)); + verify(analysisRunRepository).save(kept.capture()); + assertThat(response.status()).isEqualTo(AnalysisDAO.Status.success); + assertThat(kept.getValue().getUuid()).isEqualTo(response.uuid()); + assertThat(kept.getValue().getCreatedByUsername()).isEqualTo("user"); + assertThat(kept.getValue().getAlgorithmId()).isEqualTo("histogram"); + assertThat(kept.getValue().getResult()).isEqualTo(JsonConverters.convertObjectToJsonString(Map.of("ok", true))); + assertThat(kept.getValue().getMipVersion()).isEqualTo("9.0.0"); + assertThat(kept.getValue().getCreated()).isBeforeOrEqualTo(kept.getValue().getFinished()); + } + + @Test + void runAnalysis_doesNotKeepFailedRun() { + var execution = sampleExecution(); + when(analysisExecutionService.runAnalysis(any(UUID.class), eq(execution.analysisRequest()), any(Logger.class))) + .thenReturn(new AnalysisExecutionService.AnalysisResultDTO(500, Map.of("message", "boom"))); + + var response = analysisService.runAnalysis(authentication, USER, execution, logger); + + assertThat(response.status()).isEqualTo(AnalysisDAO.Status.error); + verify(analysisRunRepository, never()).save(any()); + } + + @Test + void runAnalysis_returnsResultWhenRunCannotBeKept() { + var execution = sampleExecution(); + when(analysisExecutionService.runAnalysis(any(UUID.class), eq(execution.analysisRequest()), any(Logger.class))) + .thenReturn(new AnalysisExecutionService.AnalysisResultDTO(200, Map.of("ok", true))); + when(analysisRunRepository.deleteCreatedBefore(any(Date.class))).thenThrow(new RuntimeException("purge")); + when(analysisRunRepository.save(any())).thenThrow(new RuntimeException("db down")); + + var response = analysisService.runAnalysis(authentication, USER, execution, logger); + + assertThat(response.status()).isEqualTo(AnalysisDAO.Status.success); + assertThat(response.result()).isEqualTo(Map.of("ok", true)); + } + + @Test + void saveAnalysisRun_rejectsInvalidRunId() { + assertThatThrownBy(() -> analysisService.saveAnalysisRun(USER, "not-a-uuid", "name", + logger)).isInstanceOf(BadRequestException.class); + verifyNoInteractions(analysisRunRepository, analysisRepository); + } + + @Test + void saveAnalysisRun_copiesKeptRunWithoutRunningAnalysis() { + var run = keptRun("user", hoursAgo(2)); + when(analysisRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); + when(analysisRepository.createAnalysisFromRun(any(), anyString(), any(), any())).thenCallRealMethod(); + + var response = analysisService.saveAnalysisRun(USER, run.getUuid().toString(), + " My analysis ", logger); + + var saved = ArgumentCaptor.forClass(AnalysisDAO.class); + verify(analysisRepository).save(saved.capture()); + var analysis = saved.getValue(); + assertThat(analysis.getUuid()).isNotEqualTo(run.getUuid()); + assertThat(analysis.getName()).isEqualTo("My analysis"); + assertThat(analysis.getCreatedBy().getUsername()).isEqualTo("user"); + assertThat(analysis.getStatus()).isEqualTo(AnalysisDAO.Status.success); + assertThat(analysis.getResult()).isEqualTo(run.getResult()); + assertThat(analysis.getAnalysisRequest()).isEqualTo(run.getAnalysisRequest()); + assertThat(analysis.getAlgorithmId()).isEqualTo("histogram"); + assertThat(analysis.getCreated()).isEqualTo(run.getCreated()); + assertThat(analysis.getFinished()).isEqualTo(run.getFinished()); + assertThat(analysis.getMipVersion()).isEqualTo("8.0.0"); + assertThat(response.uuid()).isEqualTo(analysis.getUuid()); + assertThat(response.status()).isEqualTo(AnalysisDAO.Status.success); + verifyNoInteractions(analysisExecutionService); + } + + @Test + void saveAnalysisRun_doesNotRecheckDatasetAccess() { + analysisService = service(true); + var run = keptRun("user", hoursAgo(1)); + when(analysisRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); + when(analysisRepository.createAnalysisFromRun(any(), anyString(), any(), any())).thenCallRealMethod(); + + analysisService.saveAnalysisRun(USER, run.getUuid().toString(), "name", logger); + + verifyNoInteractions(claimUtils); + } + + @Test + void saveAnalysisRun_treatsAnotherUsersRunAsMissing() { + var run = keptRun("someone-else", hoursAgo(1)); + when(analysisRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); + + assertThatThrownBy(() -> analysisService.saveAnalysisRun(USER, run.getUuid().toString(), + "name", logger)).isInstanceOf(AnalysisNotFoundException.class); + verify(analysisRepository, never()).save(any()); + } + + @Test + void saveAnalysisRun_rejectsExpiredRun() { + var run = keptRun("user", hoursAgo(25)); + when(analysisRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); + + assertThatThrownBy(() -> analysisService.saveAnalysisRun(USER, run.getUuid().toString(), + "name", logger)).isInstanceOf(AnalysisNotFoundException.class); + verify(analysisRepository, never()).save(any()); + } + + @Test + void saveAnalysisRun_rejectsUnknownRun() { + var runId = UUID.randomUUID(); + when(analysisRunRepository.findById(runId)).thenReturn(Optional.empty()); + + assertThatThrownBy(() -> analysisService.saveAnalysisRun(USER, runId.toString(), "name", logger)) + .isInstanceOf(AnalysisNotFoundException.class); + } + + @Test + void saveAnalysisRun_rejectsMissingRunId() { + assertThatThrownBy(() -> analysisService.saveAnalysisRun(USER, null, "name", logger)) + .isInstanceOf(BadRequestException.class); + verifyNoInteractions(analysisRunRepository, analysisRepository); + } + + @Test + void saveAnalysisRun_rejectsBlankName() { + assertThatThrownBy(() -> analysisService.saveAnalysisRun(USER, UUID.randomUUID().toString(), + " ", logger)).isInstanceOf(BadRequestException.class); + verifyNoInteractions(analysisRunRepository, analysisRepository); + } + + private AnalysisService service(boolean authenticationIsEnabled) { + return new AnalysisService(activeUserService, claimUtils, analysisRepository, analysisRunRepository, + analysisExecutionService, authenticationIsEnabled, "9.0.0", Duration.ofHours(24)); + } + + private AnalysisRunDAO keptRun(String owner, Date created) { + var run = new AnalysisRunDAO(); + run.setUuid(UUID.randomUUID()); + run.setCreatedByUsername(owner); + run.setAnalysisRequest(JsonConverters.convertObjectToJsonString(sampleExecution().analysisRequest())); + run.setAlgorithmId("histogram"); + run.setResult("{\"ok\":true}"); + run.setCreated(created); + run.setFinished(new Date(created.getTime() + 1000)); + run.setMipVersion("8.0.0"); + return run; + } + + private static Date hoursAgo(long hours) { + return new Date(System.currentTimeMillis() - Duration.ofHours(hours).toMillis()); + } + + private AnalysisExecutionDTO sampleExecution() { + var analysisRequest = new AnalysisRequestDTO( + null, + new AnalysisRequestDTO.AnalysisInputDataDTO( + "dm:1", + List.of("ds1"), + null, + null, + List.of("age")), + null, + new AnalysisRequestDTO.AnalysisAlgorithmDTO( + "histogram", + null, + List.of("age"), + Map.of()), + null); + return new AnalysisExecutionDTO("test analysis", analysisRequest); + } +} diff --git a/src/test/java/hbp/mip/experiment/ExperimentServiceSharedAccessTest.java b/src/test/java/hbp/mip/analysis/AnalysisServiceSharedAccessTest.java similarity index 55% rename from src/test/java/hbp/mip/experiment/ExperimentServiceSharedAccessTest.java rename to src/test/java/hbp/mip/analysis/AnalysisServiceSharedAccessTest.java index f1e6a0d68..e452f0c49 100644 --- a/src/test/java/hbp/mip/experiment/ExperimentServiceSharedAccessTest.java +++ b/src/test/java/hbp/mip/analysis/AnalysisServiceSharedAccessTest.java @@ -1,6 +1,6 @@ -package hbp.mip.experiment; +package hbp.mip.analysis; -import hbp.mip.algorithm.AnalysisService; +import hbp.mip.algorithm.AnalysisExecutionService; import hbp.mip.user.ActiveUserService; import hbp.mip.user.UserDAO; import hbp.mip.user.UserDTO; @@ -41,39 +41,39 @@ import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; -/** Sharing does not open the data: readers of someone else's experiment need its datasets. Real ClaimUtils. */ +/** Sharing does not open the data: readers of someone else's analysis need its datasets. Real ClaimUtils. */ @ExtendWith(MockitoExtension.class) -class ExperimentServiceSharedAccessTest { +class AnalysisServiceSharedAccessTest { private static final String ANALYSIS = "{\"inputdata\":{\"data_model\":\"dm:1\",\"datasets\":[\"ds1\"]}}"; @Mock private ActiveUserService activeUserService; @Mock - private ExperimentRepository experimentRepository; + private AnalysisRepository analysisRepository; @Mock - private ExperimentRunRepository experimentRunRepository; + private AnalysisRunRepository analysisRunRepository; @Mock - private AnalysisService analysisService; + private AnalysisExecutionService analysisExecutionService; private final Logger logger = new Logger("reader", "test"); - private ExperimentService service; + private AnalysisService service; @BeforeEach void setUp() { ClaimUtils claimUtils = new ClaimUtils(); ReflectionTestUtils.setField(claimUtils, "allDatasetsAllowedClaim", "research_dataset_all"); - ReflectionTestUtils.setField(claimUtils, "allExperimentsAllowedClaim", "research_experiment_all"); + ReflectionTestUtils.setField(claimUtils, "allAnalysesAllowedClaim", "research_experiment_all"); ReflectionTestUtils.setField(claimUtils, "datasetClaimPrefix", "research_dataset_"); - service = new ExperimentService(activeUserService, claimUtils, experimentRepository, experimentRunRepository, - analysisService, true, "9.0.0", Duration.ofHours(24)); + service = new AnalysisService(activeUserService, claimUtils, analysisRepository, analysisRunRepository, + analysisExecutionService, true, "9.0.0", Duration.ofHours(24)); lenient().when(activeUserService.getActiveUser(any())) .thenReturn(new UserDTO("reader", "Reader", "reader@example.org", "subject", true)); } @Test - void sharedExperimentNeedsItsDatasets() { - ExperimentDAO shared = stored(experiment("owner", true, ANALYSIS)); + void sharedAnalysisNeedsItsDatasets() { + AnalysisDAO shared = stored(analysis("owner", true, ANALYSIS)); assertThatThrownBy(() -> read(shared, "research_dataset_other")).isInstanceOf(UnauthorizedException.class); assertThat(read(shared, "research_dataset_ds1")).isSameAs(shared); @@ -81,98 +81,98 @@ void sharedExperimentNeedsItsDatasets() { } @Test - void sharedExperimentWithoutKnownDatasetsIsRefused() { - ExperimentDAO shared = stored(experiment("owner", true, "{}")); + void sharedAnalysisWithoutKnownDatasetsIsRefused() { + AnalysisDAO shared = stored(analysis("owner", true, "{}")); assertThatThrownBy(() -> read(shared, "research_dataset_ds1")).isInstanceOf(UnauthorizedException.class); } @Test - void ownerAndAllExperimentsRoleNeedNoDatasetRole() { - ExperimentDAO mine = stored(experiment("reader", false, ANALYSIS)); + void ownerAndAllAnalysesRoleNeedNoDatasetRole() { + AnalysisDAO mine = stored(analysis("reader", false, ANALYSIS)); assertThat(read(mine)).isSameAs(mine); - ExperimentDAO others = stored(experiment("owner", false, ANALYSIS)); + AnalysisDAO others = stored(analysis("owner", false, ANALYSIS)); assertThat(read(others, "research_experiment_all")).isSameAs(others); } @Test - void unsharedExperimentStaysPrivateEvenWithItsDatasets() { - ExperimentDAO others = stored(experiment("owner", false, ANALYSIS)); + void unsharedAnalysisStaysPrivateEvenWithItsDatasets() { + AnalysisDAO others = stored(analysis("owner", false, ANALYSIS)); assertThatThrownBy(() -> read(others, "research_dataset_ds1")).isInstanceOf(UnauthorizedException.class); } @Test - void listAsksTheDatabaseOnlyForSharedExperimentsOnTheUsersDatasets() { + void listAsksTheDatabaseOnlyForSharedAnalysesOnTheUsersDatasets() { CriteriaBuilder cb = listedWith("research_dataset_DS1", "research_dataset_ds2", "other_role"); verify(cb).literal("[\"ds1\",\"ds2\"]"); } @Test - void listDoesNotFilterOnDatasetsForTheAllDatasetsOrAllExperimentsRole() { + void listDoesNotFilterOnDatasetsForTheAllDatasetsOrAllAnalysesRole() { verify(listedWith("research_dataset_all"), never()).literal(anyString()); verify(listedWith("research_experiment_all"), never()).literal(anyString()); } @Test void listWithNothingVisibleIsNoContent() { - when(experimentRepository.findAll(any(Specification.class), any(Pageable.class))).thenReturn(Page.empty()); + when(analysisRepository.findAll(any(Specification.class), any(Pageable.class))).thenReturn(Page.empty()); assertThatThrownBy(() -> list()).isInstanceOf(NoContent.class); } @Test void storedAnalysisThatIsNotJsonListsAsNoAnalysisAndIsRefusedToOthers() { - String errorMessage = "Failed to serialize the analysis"; - when(experimentRepository.findAll(any(Specification.class), any(Pageable.class))) - .thenReturn(new PageImpl<>(List.of(experiment("reader", false, errorMessage)))); + String errorMessage = "Failed to serialize the analysisRequest"; + when(analysisRepository.findAll(any(Specification.class), any(Pageable.class))) + .thenReturn(new PageImpl<>(List.of(analysis("reader", false, errorMessage)))); - assertThat(list().experiments()).singleElement().satisfies(listed -> assertThat(listed.analysis()).isNull()); + assertThat(list().analyses()).singleElement().satisfies(listed -> assertThat(listed.analysisRequest()).isNull()); - ExperimentDAO shared = stored(experiment("owner", true, errorMessage)); + AnalysisDAO shared = stored(analysis("owner", true, errorMessage)); assertThatThrownBy(() -> read(shared, "research_dataset_ds1")).isInstanceOf(UnauthorizedException.class); } - private ExperimentsDTO list(String... authorities) { - return service.getExperiments(user(authorities), null, null, null, null, true, false, false, 0, 10, "created", + private AnalysesDTO list(String... authorities) { + return service.getAnalyses(user(authorities), null, null, null, null, true, false, false, 0, 10, "created", true, logger); } @SuppressWarnings("unchecked") private CriteriaBuilder listedWith(String... authorities) { - clearInvocations(experimentRepository); - when(experimentRepository.findAll(any(Specification.class), any(Pageable.class))) - .thenReturn(new PageImpl<>(List.of(experiment("reader", false, ANALYSIS)))); + clearInvocations(analysisRepository); + when(analysisRepository.findAll(any(Specification.class), any(Pageable.class))) + .thenReturn(new PageImpl<>(List.of(analysis("reader", false, ANALYSIS)))); list(authorities); - ArgumentCaptor> spec = ArgumentCaptor.forClass(Specification.class); - verify(experimentRepository).findAll(spec.capture(), any(Pageable.class)); + ArgumentCaptor> spec = ArgumentCaptor.forClass(Specification.class); + verify(analysisRepository).findAll(spec.capture(), any(Pageable.class)); CriteriaBuilder cb = mock(CriteriaBuilder.class, RETURNS_DEEP_STUBS); spec.getValue().toPredicate(mock(Root.class, RETURNS_DEEP_STUBS), mock(CriteriaQuery.class, RETURNS_DEEP_STUBS), cb); return cb; } - private ExperimentDAO read(ExperimentDAO experiment, String... authorities) { - return service.assertExperimentAccessible(user(authorities), experiment.getUuid().toString(), logger); + private AnalysisDAO read(AnalysisDAO analysis, String... authorities) { + return service.assertAnalysisAccessible(user(authorities), analysis.getUuid().toString(), logger); } - private ExperimentDAO stored(ExperimentDAO experiment) { - when(experimentRepository.loadExperiment(experiment.getUuid().toString(), logger)).thenReturn(experiment); - return experiment; + private AnalysisDAO stored(AnalysisDAO analysis) { + when(analysisRepository.loadAnalysis(analysis.getUuid().toString(), logger)).thenReturn(analysis); + return analysis; } private static Authentication user(String... authorities) { return new TestingAuthenticationToken("reader", "n/a", authorities); } - private static ExperimentDAO experiment(String owner, boolean shared, String analysis) { - ExperimentDAO experiment = new ExperimentDAO(); - experiment.setUuid(UUID.randomUUID()); - experiment.setCreatedBy(new UserDAO(owner, owner, owner + "@example.org", owner)); - experiment.setShared(shared); - experiment.setAnalysis(analysis); - return experiment; + private static AnalysisDAO analysis(String owner, boolean shared, String analysisRequest) { + AnalysisDAO analysis = new AnalysisDAO(); + analysis.setUuid(UUID.randomUUID()); + analysis.setCreatedBy(new UserDAO(owner, owner, owner + "@example.org", owner)); + analysis.setShared(shared); + analysis.setAnalysisRequest(analysisRequest); + return analysis; } } diff --git a/src/test/java/hbp/mip/analysis/BackendPersistenceIT.java b/src/test/java/hbp/mip/analysis/BackendPersistenceIT.java new file mode 100644 index 000000000..0f04e0866 --- /dev/null +++ b/src/test/java/hbp/mip/analysis/BackendPersistenceIT.java @@ -0,0 +1,314 @@ +package hbp.mip.analysis; + +import hbp.mip.algorithm.AnalysisExecutionService; +import hbp.mip.configurations.PersistenceConfiguration; +import hbp.mip.study.*; +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.ClaimUtils; +import hbp.mip.utils.Exceptions.AnalysisNotFoundException; +import hbp.mip.utils.Exceptions.ConflictException; +import hbp.mip.utils.Exceptions.UnauthorizedException; +import hbp.mip.utils.Logger; +import org.flywaydb.core.Flyway; +import org.flywaydb.core.api.MigrationVersion; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.config.BeanPostProcessor; +import org.springframework.boot.context.properties.ConfigurationPropertiesBindingPostProcessor; +import org.springframework.boot.convert.ApplicationConversionService; +import org.springframework.context.annotation.AnnotationConfigApplicationContext; +import org.springframework.core.env.MapPropertySource; +import org.springframework.jdbc.core.JdbcTemplate; +import org.springframework.jdbc.datasource.DriverManagerDataSource; +import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean; +import org.springframework.security.authentication.TestingAuthenticationToken; + +import java.nio.charset.StandardCharsets; +import java.util.*; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.*; + +/** Real PostgreSQL only. Old names below describe the immutable V5 migration fixture. */ +class BackendPersistenceIT { + private static final String REQUEST = """ + { "request_id":"historic-id", "inputdata":{"data_model":"dm:1","datasets":["DS1"], + "validation_datasets":["DS2"],"variables":["age"],"filters":{"condition":"AND"}}, + "preprocessing":[{"name":"scale","parameters":{"method":"standard"}}], + "algorithm":{"name":"histogram","x":["age"],"parameters":{"bins":10}},"flags":{"option":true} } + """; + private static final String RESULT = "{ \"n_obs\":217, \"p\":null, \"large\":9007199254740993, \"table\":{\"se\":null} }"; + private static final String SIMPLE_REQUEST = "{\"inputdata\":{\"datasets\":[\"ds1\"]},\"algorithm\":{\"name\":\"histogram\"}}"; + private static final Logger LOGGER = new Logger("owner", "integration-test"); + + private DriverManagerDataSource database; + private DriverManagerDataSource scopedDatabase; + private JdbcTemplate jdbc; + private String schema; + private AnnotationConfigApplicationContext context; + private final AnalysisExecutionService execution = mock(AnalysisExecutionService.class); + + @BeforeEach + void createIsolatedSchema() { + String url = Objects.requireNonNull(System.getProperty("it.database.url"), "Use -Ppostgres-integration"); + String username = System.getProperty("it.database.username"); + String password = System.getProperty("it.database.password"); + database = new DriverManagerDataSource(url, username, password); + schema = "terminology_" + UUID.randomUUID().toString().replace("-", ""); + new JdbcTemplate(database).execute("CREATE SCHEMA " + schema); + scopedDatabase = new DriverManagerDataSource(url + (url.contains("?") ? "&" : "?") + "currentSchema=" + schema, + username, password); + jdbc = new JdbcTemplate(scopedDatabase); + } + + @AfterEach + void removeIsolatedSchema() { + if (context != null) { + context.close(); + } + if (database != null && schema != null) { + new JdbcTemplate(database).execute("DROP SCHEMA IF EXISTS " + schema + " CASCADE"); + } + } + + @Test + void freshDatabaseMigratesAndStartsTheRealJpaConfiguration() { + migrate(null); + startContext(); + assertThat(context.getBean(AnalysisRepository.class).count()).isZero(); + assertThat(context.getBean(AnalysisRunRepository.class).count()).isZero(); + assertThat(context.getBean(StudyRepository.class).count()).isZero(); + assertNoObsoleteSchemaObjects(); + assertThat(jdbc.queryForObject("SELECT proargnames[1] FROM pg_proc WHERE oid = " + + "'analysis_datasets_readable(text,text)'::regprocedure", String.class)).isEqualTo("analysis_request"); + assertThat(jdbc.queryForObject("SELECT count(*) FROM flyway_schema_history WHERE success", Integer.class)) + .isEqualTo(6); + } + + @Test + void populatedUpgradePreservesEveryValueAndAllMembershipOrderings() { + migrate("5"); + seedV5(); + var records = snapshot("experiment", "uuid"); + var drafts = snapshot("experiment_run", "uuid"); + var studies = snapshot("experiment_folder", "id"); + var groups = snapshot("experiment_set", "id"); + var members = snapshot("experiment_folder_member", "id"); + + migrate(null); + + assertThat(snapshot("analysis", "uuid")).isEqualTo(records); + assertThat(snapshot("analysis_run", "uuid")).isEqualTo(drafts); + assertThat(snapshot("study", "id")).isEqualTo(studies); + assertThat(snapshot("analysis_group", "id")).isEqualTo(groups); + assertThat(snapshot("study_member", "id")).isEqualTo(members); + assertNoObsoleteSchemaObjects(); + startContext(); + var study = context.getBean(StudyService.class).getStudy(principal("owner"), id(101).toString(), LOGGER); + assertThat(study.analysisIds()).containsExactly(id(2).toString(), id(1).toString(), id(3).toString()); + assertThat(study.groups()).singleElement().satisfies(group -> { + assertThat(group.id()).isEqualTo(id(111).toString()); + assertThat(group.analysisIds()).containsExactly(id(2).toString(), id(1).toString()); + }); + } + + @Test + void renamedFunctionMakesExactlyTheSameDatasetDecisionsAsV5() { + migrate("5"); + var requests = Arrays.asList(REQUEST, SIMPLE_REQUEST, null, "", "not JSON", "{}", "null", "[]", + "{\"inputdata\":{\"datasets\":[]}}", "{\"inputdata\":{\"datasets\":\"ds1\"}}", + "{\"inputdata\":{\"datasets\":[\"DS1\"],\"validation_datasets\":null}}", + "{\"inputdata\":{\"datasets\":[\"ds1\"],\"validation_datasets\":\"ds2\"}}", + "{\"inputdata\":{\"datasets\":[null]}}"); + var allowed = Arrays.asList("[]", "[\"ds1\"]", "[\"ds1\",\"ds2\"]", "[\"DS1\"]", null, "invalid JSON"); + List before = new ArrayList<>(); + requests.forEach(request -> allowed.forEach(grants -> before.add(readable("experiment", request, grants)))); + assertThat(readable("experiment", REQUEST, "[\"ds1\",\"ds2\"]")).isTrue(); + assertThat(readable("experiment", REQUEST, "[\"ds1\"]")).isFalse(); + + migrate(null); + + List after = new ArrayList<>(); + requests.forEach(request -> allowed.forEach(grants -> after.add(readable("analysis", request, grants)))); + assertThat(after).containsExactlyElementsOf(before); + } + + @Test + void migratedRunsQueriesAndStudyOperationsKeepTheirBehavior() { + migrate("5"); + seedV5(); + migrate(null); + startContext(); + var analyses = context.getBean(AnalysisService.class); + var repository = context.getBean(AnalysisRepository.class); + + var first = analyses.saveAnalysisRun(user("owner"), id(20).toString(), "Saved", LOGGER); + var second = analyses.saveAnalysisRun(user("owner"), id(20).toString(), "Saved again", LOGGER); + assertThat(first.uuid()).isNotEqualTo(second.uuid()).isNotEqualTo(id(20)); + var saved = repository.findByUuid(first.uuid()); + var draft = context.getBean(AnalysisRunRepository.class).findById(id(20)).orElseThrow(); + assertThat(saved.getAnalysisRequest()).isEqualTo(REQUEST); + assertThat(saved.getResult()).isEqualTo(RESULT); + assertThat(saved.getCreated()).isEqualTo(draft.getCreated()); + assertThat(saved.getFinished()).isEqualTo(draft.getFinished()); + assertThat(saved.getMipVersion()).isEqualTo("historic-version"); + assertThat(saved.getCreatedBy().getUsername()).isEqualTo("owner"); + assertThat(saved.isShared()).isFalse(); + assertThat(context.getBean(AnalysisRunRepository.class).count()).isEqualTo(3); + verifyNoInteractions(execution); + for (int unavailable : List.of(21, 22)) { + assertThatThrownBy(() -> analyses.saveAnalysisRun(user("owner"), id(unavailable).toString(), "No", LOGGER)) + .isInstanceOf(AnalysisNotFoundException.class); + } + + var reader = principal("reader", "research_dataset_ds1"); + var page = analyses.getAnalyses(reader, null, null, null, null, true, false, false, + 0, 1, "created", true, LOGGER); + assertThat(page.totalAnalyses()).isEqualTo(2); + assertThat(page.totalPages()).isEqualTo(2); + assertThat(page.analyses()).hasSize(1); + assertThatThrownBy(() -> analyses.getAnalysis(reader, id(1).toString(), LOGGER)) + .isInstanceOf(UnauthorizedException.class); + assertThat(analyses.getAnalysis(principal("reader", "research_dataset_ds1", "research_dataset_ds2"), + id(1).toString(), LOGGER).uuid()).isEqualTo(id(1)); + assertThat(analyses.getAnalysis(principal("reader", "research_experiment_all"), id(3).toString(), LOGGER).uuid()) + .isEqualTo(id(3)); + assertThatThrownBy(() -> analyses.deleteAnalysis(user("reader"), id(2).toString(), LOGGER)) + .isInstanceOf(UnauthorizedException.class); + + var studies = context.getBean(StudyService.class); + var owner = principal("owner"); + assertThatThrownBy(() -> studies.createStudy(owner, new CreateStudyDTO(" FIRST study ", null), LOGGER)) + .isInstanceOf(ConflictException.class); + var initial = studies.getStudy(owner, id(101).toString(), LOGGER); + assertThat(studies.addAnalysis(owner, id(101).toString(), new AddStudyMemberDTO(id(1).toString()), LOGGER)) + .isEqualTo(initial); + var moved = studies.updateGroupMembership(owner, id(102).toString(), id(1).toString(), + new UpdateAnalysisGroupMembershipDTO(null), LOGGER); + assertThat(moved.analysisIds()).contains(id(1).toString()); + assertThat(moved.groups().getFirst().analysisIds()).isEmpty(); + assertThat(studies.getStudy(owner, id(101).toString(), LOGGER).groups().getFirst().analysisIds()) + .contains(id(1).toString()); + var ungrouped = studies.deleteGroup(owner, id(101).toString(), id(111).toString(), LOGGER); + assertThat(ungrouped.analysisIds()).containsExactlyElementsOf(initial.analysisIds()); + assertThat(ungrouped.groups()).isEmpty(); + studies.deleteStudy(owner, id(101).toString(), LOGGER); + assertThat(repository.findByUuid(id(1))).isNotNull(); + assertThat(studies.getStudy(owner, id(102).toString(), LOGGER).analysisIds()).contains(id(1).toString()); + analyses.deleteAnalysis(user("owner"), id(1).toString(), LOGGER); + assertThat(studies.getStudy(owner, id(102).toString(), LOGGER).analysisIds()).isEmpty(); + } + + private void migrate(String target) { + var configuration = Flyway.configure().dataSource(scopedDatabase).schemas(schema).defaultSchema(schema); + if (target != null) { + configuration.target(MigrationVersion.fromVersion(target)); + } + configuration.load().migrate(); + } + + private void startContext() { + context = new AnnotationConfigApplicationContext(); + context.getBeanFactory().setConversionService(ApplicationConversionService.getSharedInstance()); + context.getEnvironment().getPropertySources().addFirst(new MapPropertySource("integration", Map.of( + "spring.datasource.url", scopedDatabase.getUrl(), + "spring.datasource.username", System.getProperty("it.database.username"), + "spring.datasource.password", System.getProperty("it.database.password"), + "authentication.enabled", "true", + "authentication.all_analyses_allowed_claim", "research_experiment_all", + "authentication.all_datasets_allowed_claim", "research_dataset_all", + "authentication.dataset_claim_prefix", "research_dataset_", + "mip.version", "current-version", "analyses.run-draft-ttl", "PT24H"))); + ConfigurationPropertiesBindingPostProcessor.register(context); + context.getBeanFactory().addBeanPostProcessor(new BeanPostProcessor() { + @Override + public Object postProcessBeforeInitialization(Object bean, String name) { + if (bean instanceof LocalContainerEntityManagerFactoryBean factory) { + factory.setJpaPropertyMap(Map.of("hibernate.hbm2ddl.auto", "validate")); + } + return bean; + } + }); + var users = mock(ActiveUserService.class); + when(users.getActiveUser(any())).thenAnswer(call -> user(call.getArgument(0).getName())); + context.registerBean(ActiveUserService.class, () -> users); + context.registerBean(AnalysisExecutionService.class, () -> execution); + context.register(PersistenceConfiguration.class, ClaimUtils.class, AnalysisService.class, StudyService.class); + context.refresh(); + } + + private void seedV5() { + for (String username : List.of("owner", "reader", "other")) { + jdbc.update("INSERT INTO \"user\" (username, subject_id, agree_nda) VALUES (?, ?, true)", username, username + "-subject"); + } + for (int n = 1; n <= 7; n++) { + String owner = n == 4 ? "reader" : n == 5 ? "other" : "owner"; + String request = switch (n) { + case 1 -> REQUEST; + case 2, 3 -> SIMPLE_REQUEST; + case 5 -> "{}"; + case 7 -> null; + default -> "historic serialization error"; + }; + jdbc.update("INSERT INTO experiment (uuid,name,created_by_username,status,result,finished,analysis,algorithm_id," + + "created,updated,shared,viewed,mip_version) VALUES (?,?,?,?,?,CURRENT_TIMESTAMP,?,?," + + "CURRENT_TIMESTAMP - interval '3 hours',CURRENT_TIMESTAMP,?,?,?)", + id(n), "Historical " + n, owner, n == 3 ? "pending" : n == 6 ? "error" : "success", + RESULT, request, "histogram", n != 3 && n != 4, n == 2, "historic-version"); + } + for (int n = 20; n <= 22; n++) { + jdbc.update("INSERT INTO experiment_run (uuid,created_by_username,result,analysis,algorithm_id,created,finished,mip_version) " + + "VALUES (?,?,?,?,?,CURRENT_TIMESTAMP - (? * interval '1 hour'),CURRENT_TIMESTAMP,?)", + id(n), n == 22 ? "other" : "owner", RESULT, REQUEST, "histogram", n == 21 ? 25 : 2, "historic-version"); + } + jdbc.update("INSERT INTO experiment_folder (id,owner_username,name,sort_order) VALUES (?, 'owner', 'First study', 7)," + + "(?, 'owner', 'Second study', 2)", id(101), id(102)); + jdbc.update("INSERT INTO experiment_set (id,folder_id,name,sort_order) VALUES (?, ?, 'First group', 5)," + + "(?, ?, 'Second group', 3)", id(111), id(101), id(112), id(102)); + jdbc.update("INSERT INTO experiment_folder_member (id,folder_id,experiment_uuid,set_id,folder_position,set_position) " + + "VALUES (?, ?, ?, ?, 8, 3),(?, ?, ?, ?, 4, 1),(?, ?, ?, NULL, 10, NULL),(?, ?, ?, ?, 9, 1)", + id(121), id(101), id(1), id(111), id(122), id(101), id(2), id(111), + id(123), id(101), id(3), id(124), id(102), id(1), id(112)); + } + + private List> snapshot(String table, String key) { + // PostgreSQL column renames preserve column order, so this compares every value, including nulls. + return jdbc.query("SELECT * FROM " + table + " ORDER BY " + key, (row, index) -> { + List values = new ArrayList<>(); + for (int column = 1; column <= row.getMetaData().getColumnCount(); column++) { + values.add(row.getObject(column)); + } + return values; + }); + } + + private Boolean readable(String prefix, String request, String allowed) { + return jdbc.queryForObject("SELECT " + prefix + "_datasets_readable(?::text, ?::text)", Boolean.class, request, allowed); + } + + private void assertNoObsoleteSchemaObjects() { + assertThat(jdbc.queryForList("SELECT tablename FROM pg_tables WHERE schemaname = ? AND tablename LIKE '%experiment%'", + String.class, schema)).isEmpty(); + assertThat(jdbc.queryForList("SELECT indexname FROM pg_indexes WHERE schemaname = ? AND indexname LIKE '%experiment%'", + String.class, schema)).isEmpty(); + assertThat(jdbc.queryForList("SELECT conname FROM pg_constraint c JOIN pg_namespace n ON n.oid = c.connamespace " + + "WHERE n.nspname = ? AND conname LIKE '%experiment%'", String.class, schema)).isEmpty(); + assertThat(jdbc.queryForObject("SELECT to_regprocedure('experiment_datasets_readable(text,text)')", String.class)).isNull(); + } + + private static UUID id(int number) { + return UUID.nameUUIDFromBytes(("fixture-" + number).getBytes(StandardCharsets.UTF_8)); + } + + private static UserDTO user(String username) { + return new UserDTO(username, username, username + "@example.org", username + "-subject", true); + } + + private static TestingAuthenticationToken principal(String username, String... roles) { + return new TestingAuthenticationToken(username, null, roles); + } +} diff --git a/src/test/java/hbp/mip/configurations/DpopSecurityChainTest.java b/src/test/java/hbp/mip/configurations/DpopSecurityChainTest.java index b9aa14fa0..885cc59d5 100644 --- a/src/test/java/hbp/mip/configurations/DpopSecurityChainTest.java +++ b/src/test/java/hbp/mip/configurations/DpopSecurityChainTest.java @@ -129,9 +129,9 @@ void forgetTheRequest() { void aDpopBoundLaptopTokenOverTheDpopSchemeIsNotBlockedByCsrfAndGetsThrough() throws Exception { storedUser("alice", true); - mvc.perform(withDpop(post("/services/experiments"), laptopToken("alice"))) + mvc.perform(withDpop(post("/services/analyses"), laptopToken("alice"))) .andExpect(status().isOk()) - .andExpect(content().string("experiments")); + .andExpect(content().string("analyses")); } @Test @@ -139,7 +139,7 @@ void theSameProofIsAReplay() throws Exception { storedUser("alice", true); String proof = proof(laptopToken("alice")); - MockHttpServletRequestBuilder request = post("/services/experiments").contextPath("/services") + MockHttpServletRequestBuilder request = post("/services/analyses").contextPath("/services") .header("Authorization", "DPoP " + laptopToken("alice")) .header("DPoP", proof) .with(inRequestScope()); @@ -153,7 +153,7 @@ void aDpopBoundLaptopTokenIsRefusedOverBearer() throws Exception { storedUser("alice", true); // In request scope, so the refusal tests the Bearer scheme, not the missing request scope. - mvc.perform(withBearer(get("/services/experiments"), laptopToken("alice")).with(inRequestScope())) + mvc.perform(withBearer(get("/services/analyses"), laptopToken("alice")).with(inRequestScope())) .andExpect(status().isUnauthorized()); } @@ -162,9 +162,9 @@ void aLaptopTokenWithoutTheBindingIsRefused() throws Exception { storedUser("alice", true); String unbound = laptopToken("alice").replace("." + THUMBPRINT, ""); - assertThat(mvc.perform(withBearer(get("/services/experiments"), unbound)) + assertThat(mvc.perform(withBearer(get("/services/analyses"), unbound)) .andReturn().getResponse().getStatus()).isEqualTo(401); - assertThat(mvc.perform(withDpop(post("/services/experiments"), unbound)) + assertThat(mvc.perform(withDpop(post("/services/analyses"), unbound)) .andReturn().getResponse().getStatus()).isEqualTo(401); } @@ -172,7 +172,7 @@ void aLaptopTokenWithoutTheBindingIsRefused() throws Exception { void aPlatformTokenOverBearerIsUnaffected() throws Exception { storedUser("alice", true); - mvc.perform(withBearer(get("/services/experiments"), "alice")) + mvc.perform(withBearer(get("/services/analyses"), "alice")) .andExpect(status().isOk()); } @@ -183,8 +183,8 @@ void aProofForAnotherUrlIsRefused() throws Exception { // What a request looks like when nginx does not pass X-Forwarded-Proto/Host: the proof names the // public https URL, but the backend still sees its own http one. - String proofForPublicUrl = proof(token, "https://portal.example.org/services/experiments"); - int status = mvc.perform(post("/services/experiments").contextPath("/services") + String proofForPublicUrl = proof(token, "https://portal.example.org/services/analyses"); + int status = mvc.perform(post("/services/analyses").contextPath("/services") .header("Authorization", "DPoP " + token) .header("DPoP", proofForPublicUrl) .with(inRequestScope())) @@ -197,7 +197,7 @@ void aProofForAnotherUrlIsRefused() throws Exception { void aDpopRequestWithoutAProofIsRefused() throws Exception { storedUser("alice", true); - mvc.perform(post("/services/experiments").contextPath("/services") + mvc.perform(post("/services/analyses").contextPath("/services") .header("Authorization", "DPoP " + laptopToken("alice")) .with(inRequestScope())) .andExpect(status().isUnauthorized()); @@ -205,7 +205,7 @@ void aDpopRequestWithoutAProofIsRefused() throws Exception { // The proof's htu is the request URL as the backend sees it; MockMvc serves http://localhost/services. private static String proof(String accessToken) { - return proof(accessToken, "http://localhost/services/experiments"); + return proof(accessToken, "http://localhost/services/analyses"); } private static String proof(String accessToken, String htu) { @@ -330,14 +330,14 @@ ClientRegistrationRepository clientRegistrationRepository() { @RestController static class StandInAPI { - @GetMapping("/experiments") - String experiments() { - return "experiments"; + @GetMapping("/analyses") + String analyses() { + return "analyses"; } - @PostMapping("/experiments") - String runExperiments() { - return "experiments"; + @PostMapping("/analyses") + String runAnalyses() { + return "analyses"; } } } diff --git a/src/test/java/hbp/mip/configurations/LoginRedirectTest.java b/src/test/java/hbp/mip/configurations/LoginRedirectTest.java index 79990e4d0..f9bf8f969 100644 --- a/src/test/java/hbp/mip/configurations/LoginRedirectTest.java +++ b/src/test/java/hbp/mip/configurations/LoginRedirectTest.java @@ -35,10 +35,16 @@ void protocolRelativePathsStayOnThisSite() throws Exception { assertThat(targetFor("/\\evil.example/x", "")).isEqualTo("/services/evil.example/x"); } + @Test + void analysisStudioPathAndNavigationStateAreKept() throws Exception { + assertThat(targetFor("/analysis-studio?analysisId=123#results", "https://portal.example/")) + .isEqualTo("https://portal.example/analysis-studio?analysisId=123#results"); + } + @Test void ordinaryPathIsKept() throws Exception { - assertThat(targetFor("/experiments?id=1#top", "https://portal.example/")) - .isEqualTo("https://portal.example/experiments?id=1#top"); + assertThat(targetFor("/analyses-dashboard?id=1#top", "https://portal.example/")) + .isEqualTo("https://portal.example/analyses-dashboard?id=1#top"); } private static String targetFor(String frontendRedirect, String baseUrl) throws ServletException, IOException { diff --git a/src/test/java/hbp/mip/configurations/TermsOfUseFilterTest.java b/src/test/java/hbp/mip/configurations/TermsOfUseFilterTest.java index 30e987478..e9c44883e 100644 --- a/src/test/java/hbp/mip/configurations/TermsOfUseFilterTest.java +++ b/src/test/java/hbp/mip/configurations/TermsOfUseFilterTest.java @@ -104,7 +104,7 @@ void fallsBackToAPlain403WhenTheResolverCannotRender() throws Exception { storedUser("alice", false); authenticate(bearer("alice")); - MockHttpServletResponse response = run("GET", "/experiments"); + MockHttpServletResponse response = run("GET", "/analyses"); assertBlocked(response); assertThat(response.getErrorMessage()).isEqualTo(TermsOfUseNotAcceptedException.MESSAGE); @@ -117,7 +117,7 @@ void usernameOfAnotherSubjectIsToldAboutTheConflictNotTheTerms() throws Exceptio when(userRepository.findByUsername("alice")).thenReturn(previousHolder); authenticate(bearer("alice")); - MockHttpServletResponse response = run("GET", "/experiments"); + MockHttpServletResponse response = run("GET", "/analyses"); assertThat(response.getHeader("X-Passed")).isNull(); assertThat(response.getStatus()).isEqualTo(403); diff --git a/src/test/java/hbp/mip/configurations/TermsOfUseSecurityChainTest.java b/src/test/java/hbp/mip/configurations/TermsOfUseSecurityChainTest.java index 30a196e83..0dea97d29 100644 --- a/src/test/java/hbp/mip/configurations/TermsOfUseSecurityChainTest.java +++ b/src/test/java/hbp/mip/configurations/TermsOfUseSecurityChainTest.java @@ -73,7 +73,7 @@ /** * The terms-of-use gate through the real SecurityConfiguration filter chain, so moving the filter to a point * where the session or Bearer authentication is not yet known fails here. The real ActiveUserAPI and - * ControllerExceptionHandler render the responses; /experiments is a stand-in. No datasource, Keycloak or + * ControllerExceptionHandler render the responses; /analyses is a stand-in. No datasource, Keycloak or * Exaflow. A Bearer token's value is {@code [.[.[.]]]}; azp defaults to the platform * client, typ to Bearer and sub to the username. */ @@ -107,21 +107,21 @@ void setUp() { void bearerUserWhoHasNotAgreedIsBlocked() throws Exception { storedUser("alice", false); - mvc.perform(withBearer(get("/services/experiments"), "alice")) + mvc.perform(withBearer(get("/services/analyses"), "alice")) .andExpect(status().isForbidden()) .andExpect(jsonPath("$.statusCode").value(403)) .andExpect(jsonPath("$.message").value(TermsOfUseNotAcceptedException.MESSAGE)) .andExpect(jsonPath("$.timestamp").exists()) - .andExpect(jsonPath("$.description").value("uri=/services/experiments")); + .andExpect(jsonPath("$.description").value("uri=/services/analyses")); } @Test void bearerUserWhoAgreedReachesTheController() throws Exception { storedUser("alice", true); - mvc.perform(withBearer(get("/services/experiments"), "alice")) + mvc.perform(withBearer(get("/services/analyses"), "alice")) .andExpect(status().isOk()) - .andExpect(content().string("experiments")); + .andExpect(content().string("analyses")); } @Test @@ -129,7 +129,7 @@ void bearerTokenOfAnotherClientIsRejected() throws Exception { storedUser("alice", true); // e.g. another federation's portal token, whatever its aud says. - mvc.perform(withBearer(get("/services/experiments"), "alice.other-federation")) + mvc.perform(withBearer(get("/services/analyses"), "alice.other-federation")) .andExpect(status().isUnauthorized()); } @@ -137,7 +137,7 @@ void bearerTokenOfAnotherClientIsRejected() throws Exception { void rejectedBearerTokenPublishesAFailureEventWithoutTheToken() throws Exception { failures.events.clear(); - mvc.perform(withBearer(get("/services/experiments"), "alice.other-federation")) + mvc.perform(withBearer(get("/services/analyses"), "alice.other-federation")) .andExpect(status().isUnauthorized()); assertThat(failures.events).singleElement() @@ -152,7 +152,7 @@ void everyBearerAuthenticationPublishesASuccessEvent() throws Exception { storedUser("alice", true); failures.successes.clear(); - mvc.perform(withBearer(get("/services/experiments"), "alice")) + mvc.perform(withBearer(get("/services/analyses"), "alice")) .andExpect(status().isOk()); assertThat(failures.successes).singleElement().satisfies(event -> { @@ -165,7 +165,7 @@ void everyBearerAuthenticationPublishesASuccessEvent() throws Exception { // no CSRF token; without this exemption Spring would 403 every DPoP POST. @Test void aDpopSchemePostIsExemptFromCsrf() throws Exception { - int status = mvc.perform(post("/services/experiments").contextPath("/services") + int status = mvc.perform(post("/services/analyses").contextPath("/services") .header("Authorization", "DPoP some-token")) .andReturn().getResponse().getStatus(); @@ -177,7 +177,7 @@ void aDpopSchemePostIsExemptFromCsrf() throws Exception { @Test void aDpopSchemeWithoutATokenIsNotExemptFromCsrf() throws Exception { // The exemption is scheme-plus-space, like Bearer: a header that names no token gets no exemption. - mvc.perform(post("/services/experiments").contextPath("/services").header("Authorization", "DPoP")) + mvc.perform(post("/services/analyses").contextPath("/services").header("Authorization", "DPoP")) .andExpect(status().isForbidden()); } @@ -185,7 +185,7 @@ void aDpopSchemeWithoutATokenIsNotExemptFromCsrf() throws Exception { void bearerTokenOfTheLaptopClientIsAccepted() throws Exception { storedUser("alice", true); - mvc.perform(withBearer(get("/services/experiments"), "alice.mip-cli")) + mvc.perform(withBearer(get("/services/analyses"), "alice.mip-cli")) .andExpect(status().isOk()); } @@ -193,7 +193,7 @@ void bearerTokenOfTheLaptopClientIsAccepted() throws Exception { void idTokenOfThisFederationIsRejectedAsBearerToken() throws Exception { storedUser("alice", true); - mvc.perform(withBearer(get("/services/experiments"), "alice.client.ID")) + mvc.perform(withBearer(get("/services/analyses"), "alice.client.ID")) .andExpect(status().isUnauthorized()); } @@ -232,7 +232,7 @@ void usernameHeldByAnotherSubjectIsForbidden() throws Exception { mvc.perform(withBearer(get("/services/activeUser"), "alice.client.Bearer.sub-2")) .andExpect(status().isForbidden()) .andExpect(jsonPath("$.message").value(UserIdentityConflictException.MESSAGE)); - mvc.perform(withBearer(get("/services/experiments"), "alice.client.Bearer.sub-2")) + mvc.perform(withBearer(get("/services/analyses"), "alice.client.Bearer.sub-2")) .andExpect(status().isForbidden()); } @@ -240,7 +240,7 @@ void usernameHeldByAnotherSubjectIsForbidden() throws Exception { void sessionUserWhoHasNotAgreedIsBlocked() throws Exception { storedUser("alice", false); - mvc.perform(get("/services/experiments").contextPath("/services").session(session("alice"))) + mvc.perform(get("/services/analyses").contextPath("/services").session(session("alice"))) .andExpect(status().isForbidden()) .andExpect(jsonPath("$.message").value(TermsOfUseNotAcceptedException.MESSAGE)); } @@ -269,7 +269,7 @@ void authConfigIsPublic() throws Exception { void sessionPastItsMaximumAgeIsSignedOut() throws Exception { storedUser("alice", true); MockHttpSession session = session("alice"); - mvc.perform(get("/services/experiments").contextPath("/services").session(session)) + mvc.perform(get("/services/analyses").contextPath("/services").session(session)) .andExpect(status().isOk()); // MockHttpSession's creation time is fixed: an old session is one created before "now minus the maximum". @@ -282,7 +282,7 @@ public long getCreationTime() { old.setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY, session.getAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY)); - assertThat(mvc.perform(get("/services/experiments").contextPath("/services").session(old)) + assertThat(mvc.perform(get("/services/analyses").contextPath("/services").session(old)) .andReturn().getResponse().getStatus()).isIn(302, 401); assertThat(old.isInvalid()).isTrue(); } @@ -355,7 +355,7 @@ void authenticationCanOnlyBeOffForALocalPortal() { @Test void unauthenticatedRequestIsStillRejectedByAuthentication() throws Exception { - int status = mvc.perform(get("/services/experiments").contextPath("/services")) + int status = mvc.perform(get("/services/analyses").contextPath("/services")) .andReturn().getResponse().getStatus(); // 302 to the login page or 401, depending on which entry point Spring Security picks; never our 403. @@ -456,9 +456,9 @@ void recordSuccess(AuthenticationSuccessEvent event) { @RestController static class StandInAPI { - @GetMapping("/experiments") - String experiments() { - return "experiments"; + @GetMapping("/analyses") + String analyses() { + return "analyses"; } } } diff --git a/src/test/java/hbp/mip/datamodel/DataModelListingTest.java b/src/test/java/hbp/mip/datamodel/DataModelListingTest.java new file mode 100644 index 000000000..f2c1657d6 --- /dev/null +++ b/src/test/java/hbp/mip/datamodel/DataModelListingTest.java @@ -0,0 +1,86 @@ +package hbp.mip.datamodel; + +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.ClaimUtils; +import hbp.mip.utils.ControllerExceptionHandler; +import hbp.mip.utils.Exceptions.NoAuthorizedDataModelsException; +import hbp.mip.utils.Exceptions.NoDataModelsAvailableException; +import hbp.mip.utils.HTTPUtil; +import hbp.mip.utils.Logger; +import org.junit.jupiter.api.Test; +import org.springframework.security.authentication.TestingAuthenticationToken; +import org.springframework.test.util.ReflectionTestUtils; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.*; +import static org.mockito.Mockito.*; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*; + +class DataModelListingTest { + private final ClaimUtils claims = mock(ClaimUtils.class); + private final DataModelService service = new DataModelService(claims); + private final TestingAuthenticationToken authentication = new TestingAuthenticationToken("user", null); + private final Logger logger = new Logger("user", "test"); + + @Test + void emptyFederationUsesDataModelTerminologyAndRemainsNotFound() throws Exception { + withMetadata("{}", () -> { + assertThatThrownBy(() -> service.getDataModels(authentication, logger)) + .isInstanceOf(NoDataModelsAvailableException.class).hasMessageContaining("data models"); + mvc().perform(get("/data-models").principal(authentication)).andExpect(status().isNotFound()) + .andExpect(jsonPath("$.statusCode").value(404)); + verifyNoInteractions(claims); + }); + } + + @Test + void inaccessibleModelsRemainForbiddenAndAnonymousModeStillListsThem() throws Exception { + when(claims.getAuthorizedDataModels(any(), eq(authentication), anyList())).thenReturn(List.of()); + withMetadata(""" + {"dm:1":{"properties":{"cdes":[{"code":"dm","version":"1","datasets":[{"code":"ds1"}]}]}}} + """, () -> { + assertThatThrownBy(() -> service.getDataModels(authentication, logger)) + .isInstanceOf(NoAuthorizedDataModelsException.class).hasMessageContaining("data models"); + mvc().perform(get("/data-models").principal(authentication)).andExpect(status().isForbidden()) + .andExpect(jsonPath("$.statusCode").value(403)); + clearInvocations(claims); + ReflectionTestUtils.setField(service, "authenticationIsEnabled", false); + assertThat(service.getDataModels(authentication, logger)).singleElement() + .satisfies(model -> assertThat(model.code()).isEqualTo("dm")); + verifyNoInteractions(claims); + }); + } + + private org.springframework.test.web.servlet.MockMvc mvc() { + var users = mock(ActiveUserService.class); + when(users.getActiveUser(any())).thenReturn(new UserDTO("user", "User", "user@example.org", "subject", true)); + return MockMvcBuilders.standaloneSetup(new DataModelAPI(users, service)) + .setControllerAdvice(new ControllerExceptionHandler()).build(); + } + + private void withMetadata(String attributes, ThrowingAction action) throws Exception { + ReflectionTestUtils.setField(service, "authenticationIsEnabled", true); + ReflectionTestUtils.setField(service, "exaflowApiToken", ""); + ReflectionTestUtils.setField(service, "exaflowAttributesUrl", "attributes"); + ReflectionTestUtils.setField(service, "exaflowDatasetsVariables", "variables"); + ReflectionTestUtils.setField(service, "exaflowCDEsMetadataUrl", "cdes"); + try (var http = mockStatic(HTTPUtil.class)) { + http.when(() -> HTTPUtil.sendGet(anyString(), anyString(), any(StringBuilder.class))) + .thenAnswer(call -> { + call.getArgument(2).append("attributes".equals(call.getArgument(0)) ? attributes : "{}"); + return null; + }); + action.run(); + } + } + + private interface ThrowingAction { + void run() throws Exception; + } +} diff --git a/src/test/java/hbp/mip/experiment/ExperimentServiceRunSaveTest.java b/src/test/java/hbp/mip/experiment/ExperimentServiceRunSaveTest.java deleted file mode 100644 index f16e5f7e4..000000000 --- a/src/test/java/hbp/mip/experiment/ExperimentServiceRunSaveTest.java +++ /dev/null @@ -1,244 +0,0 @@ -package hbp.mip.experiment; - -import hbp.mip.algorithm.AnalysisRequestDTO; -import hbp.mip.algorithm.AnalysisService; -import hbp.mip.user.ActiveUserService; -import hbp.mip.user.UserDTO; -import hbp.mip.utils.ClaimUtils; -import hbp.mip.utils.Exceptions.BadRequestException; -import hbp.mip.utils.Exceptions.ExperimentNotFoundException; -import hbp.mip.utils.JsonConverters; -import hbp.mip.utils.Logger; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.springframework.security.core.Authentication; - -import java.time.Duration; -import java.util.Date; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.UUID; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.anyString; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.verifyNoInteractions; -import static org.mockito.Mockito.when; - -@ExtendWith(MockitoExtension.class) -class ExperimentServiceRunSaveTest { - - private static final UserDTO USER = new UserDTO("user", "User", "user@example.org", "subject", true); - - @Mock - private ActiveUserService activeUserService; - - @Mock - private ClaimUtils claimUtils; - - @Mock - private ExperimentRepository experimentRepository; - - @Mock - private ExperimentRunRepository experimentRunRepository; - - @Mock - private AnalysisService analysisService; - - @Mock - private Authentication authentication; - - private final Logger logger = new Logger("user", "test"); - - private ExperimentService experimentService; - - @BeforeEach - void setUp() { - experimentService = service(false); - } - - @Test - void runExperiment_keepsSuccessfulRunForSaving() { - var execution = sampleExecution(); - when(analysisService.runAnalysis(any(UUID.class), eq(execution.analysis()), any(Logger.class))) - .thenReturn(new AnalysisService.AnalysisResultDTO(200, Map.of("ok", true))); - - var response = experimentService.runExperiment(authentication, USER, execution, logger); - - var kept = ArgumentCaptor.forClass(ExperimentRunDAO.class); - verify(experimentRunRepository).deleteCreatedBefore(any(Date.class)); - verify(experimentRunRepository).save(kept.capture()); - assertThat(response.status()).isEqualTo(ExperimentDAO.Status.success); - assertThat(kept.getValue().getUuid()).isEqualTo(response.uuid()); - assertThat(kept.getValue().getCreatedByUsername()).isEqualTo("user"); - assertThat(kept.getValue().getAlgorithmId()).isEqualTo("histogram"); - assertThat(kept.getValue().getResult()).isEqualTo(JsonConverters.convertObjectToJsonString(Map.of("ok", true))); - assertThat(kept.getValue().getMipVersion()).isEqualTo("9.0.0"); - assertThat(kept.getValue().getCreated()).isBeforeOrEqualTo(kept.getValue().getFinished()); - } - - @Test - void runExperiment_doesNotKeepFailedRun() { - var execution = sampleExecution(); - when(analysisService.runAnalysis(any(UUID.class), eq(execution.analysis()), any(Logger.class))) - .thenReturn(new AnalysisService.AnalysisResultDTO(500, Map.of("message", "boom"))); - - var response = experimentService.runExperiment(authentication, USER, execution, logger); - - assertThat(response.status()).isEqualTo(ExperimentDAO.Status.error); - verify(experimentRunRepository, never()).save(any()); - } - - @Test - void runExperiment_returnsResultWhenRunCannotBeKept() { - var execution = sampleExecution(); - when(analysisService.runAnalysis(any(UUID.class), eq(execution.analysis()), any(Logger.class))) - .thenReturn(new AnalysisService.AnalysisResultDTO(200, Map.of("ok", true))); - when(experimentRunRepository.deleteCreatedBefore(any(Date.class))).thenThrow(new RuntimeException("purge")); - when(experimentRunRepository.save(any())).thenThrow(new RuntimeException("db down")); - - var response = experimentService.runExperiment(authentication, USER, execution, logger); - - assertThat(response.status()).isEqualTo(ExperimentDAO.Status.success); - assertThat(response.result()).isEqualTo(Map.of("ok", true)); - } - - @Test - void saveExperimentRun_rejectsInvalidRunId() { - assertThatThrownBy(() -> experimentService.saveExperimentRun(USER, "not-a-uuid", "name", - logger)).isInstanceOf(BadRequestException.class); - verifyNoInteractions(experimentRunRepository, experimentRepository); - } - - @Test - void saveExperimentRun_copiesKeptRunWithoutRunningAnalysis() { - var run = keptRun("user", hoursAgo(2)); - when(experimentRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); - when(experimentRepository.createExperimentFromRun(any(), anyString(), any(), any())).thenCallRealMethod(); - - var response = experimentService.saveExperimentRun(USER, run.getUuid().toString(), - " My experiment ", logger); - - var saved = ArgumentCaptor.forClass(ExperimentDAO.class); - verify(experimentRepository).save(saved.capture()); - var experiment = saved.getValue(); - assertThat(experiment.getUuid()).isNotEqualTo(run.getUuid()); - assertThat(experiment.getName()).isEqualTo("My experiment"); - assertThat(experiment.getCreatedBy().getUsername()).isEqualTo("user"); - assertThat(experiment.getStatus()).isEqualTo(ExperimentDAO.Status.success); - assertThat(experiment.getResult()).isEqualTo(run.getResult()); - assertThat(experiment.getAnalysis()).isEqualTo(run.getAnalysis()); - assertThat(experiment.getAlgorithmId()).isEqualTo("histogram"); - assertThat(experiment.getCreated()).isEqualTo(run.getCreated()); - assertThat(experiment.getFinished()).isEqualTo(run.getFinished()); - assertThat(experiment.getMipVersion()).isEqualTo("8.0.0"); - assertThat(response.uuid()).isEqualTo(experiment.getUuid()); - assertThat(response.status()).isEqualTo(ExperimentDAO.Status.success); - verifyNoInteractions(analysisService); - } - - @Test - void saveExperimentRun_doesNotRecheckDatasetAccess() { - experimentService = service(true); - var run = keptRun("user", hoursAgo(1)); - when(experimentRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); - when(experimentRepository.createExperimentFromRun(any(), anyString(), any(), any())).thenCallRealMethod(); - - experimentService.saveExperimentRun(USER, run.getUuid().toString(), "name", logger); - - verifyNoInteractions(claimUtils); - } - - @Test - void saveExperimentRun_treatsAnotherUsersRunAsMissing() { - var run = keptRun("someone-else", hoursAgo(1)); - when(experimentRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); - - assertThatThrownBy(() -> experimentService.saveExperimentRun(USER, run.getUuid().toString(), - "name", logger)).isInstanceOf(ExperimentNotFoundException.class); - verify(experimentRepository, never()).save(any()); - } - - @Test - void saveExperimentRun_rejectsExpiredRun() { - var run = keptRun("user", hoursAgo(25)); - when(experimentRunRepository.findById(run.getUuid())).thenReturn(Optional.of(run)); - - assertThatThrownBy(() -> experimentService.saveExperimentRun(USER, run.getUuid().toString(), - "name", logger)).isInstanceOf(ExperimentNotFoundException.class); - verify(experimentRepository, never()).save(any()); - } - - @Test - void saveExperimentRun_rejectsUnknownRun() { - var runId = UUID.randomUUID(); - when(experimentRunRepository.findById(runId)).thenReturn(Optional.empty()); - - assertThatThrownBy(() -> experimentService.saveExperimentRun(USER, runId.toString(), "name", logger)) - .isInstanceOf(ExperimentNotFoundException.class); - } - - @Test - void saveExperimentRun_rejectsMissingRunId() { - assertThatThrownBy(() -> experimentService.saveExperimentRun(USER, null, "name", logger)) - .isInstanceOf(BadRequestException.class); - verifyNoInteractions(experimentRunRepository, experimentRepository); - } - - @Test - void saveExperimentRun_rejectsBlankName() { - assertThatThrownBy(() -> experimentService.saveExperimentRun(USER, UUID.randomUUID().toString(), - " ", logger)).isInstanceOf(BadRequestException.class); - verifyNoInteractions(experimentRunRepository, experimentRepository); - } - - private ExperimentService service(boolean authenticationIsEnabled) { - return new ExperimentService(activeUserService, claimUtils, experimentRepository, experimentRunRepository, - analysisService, authenticationIsEnabled, "9.0.0", Duration.ofHours(24)); - } - - private ExperimentRunDAO keptRun(String owner, Date created) { - var run = new ExperimentRunDAO(); - run.setUuid(UUID.randomUUID()); - run.setCreatedByUsername(owner); - run.setAnalysis(JsonConverters.convertObjectToJsonString(sampleExecution().analysis())); - run.setAlgorithmId("histogram"); - run.setResult("{\"ok\":true}"); - run.setCreated(created); - run.setFinished(new Date(created.getTime() + 1000)); - run.setMipVersion("8.0.0"); - return run; - } - - private static Date hoursAgo(long hours) { - return new Date(System.currentTimeMillis() - Duration.ofHours(hours).toMillis()); - } - - private ExperimentExecutionDTO sampleExecution() { - var analysis = new AnalysisRequestDTO( - null, - new AnalysisRequestDTO.AnalysisInputDataDTO( - "dm:1", - List.of("ds1"), - null, - null, - List.of("age")), - null, - new AnalysisRequestDTO.AnalysisAlgorithmDTO( - "histogram", - null, - List.of("age"), - Map.of()), - null); - return new ExperimentExecutionDTO("test experiment", analysis); - } -} diff --git a/src/test/java/hbp/mip/folder/ExperimentFolderAPITest.java b/src/test/java/hbp/mip/folder/ExperimentFolderAPITest.java deleted file mode 100644 index c7f7ab6a8..000000000 --- a/src/test/java/hbp/mip/folder/ExperimentFolderAPITest.java +++ /dev/null @@ -1,289 +0,0 @@ -package hbp.mip.folder; - -import hbp.mip.user.ActiveUserService; -import hbp.mip.user.UserDTO; -import hbp.mip.utils.ControllerExceptionHandler; -import hbp.mip.utils.Exceptions.BadRequestException; -import hbp.mip.utils.Exceptions.ConflictException; -import hbp.mip.utils.Exceptions.ExperimentNotFoundException; -import hbp.mip.utils.Exceptions.UnauthorizedException; -import hbp.mip.utils.Logger; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; -import org.springframework.security.core.Authentication; -import org.springframework.test.web.servlet.MockMvc; -import org.springframework.test.web.servlet.setup.MockMvcBuilders; - -import java.util.List; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.lenient; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch; -import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; -import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; -import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; -import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; - -/** - * The contract, as a test. Body field names, response field names, and the status each failure answers - * with are what the frontend codes against, and none of them are covered by service unit tests: those - * call the service directly and never see Jackson or {@code ControllerExceptionHandler}. - * - * Standalone MockMvc on purpose — no security context, no datasource. The active user is the request - * principal, which is also how the real request reaches the controller. - */ -@ExtendWith(MockitoExtension.class) -class ExperimentFolderAPITest { - - private static final String FOLDER_ID = "11111111-1111-1111-1111-111111111111"; - private static final String SET_ID = "22222222-2222-2222-2222-222222222222"; - private static final String RUN_ID = "33333333-3333-3333-3333-333333333333"; - - @Mock - private ExperimentFolderService service; - - @Mock - private ActiveUserService activeUserService; - - private final Authentication principal = new UsernamePasswordAuthenticationToken("user", null); - - private MockMvc mvc; - - @BeforeEach - void setUp() { - mvc = MockMvcBuilders - .standaloneSetup(new ExperimentFolderAPI(service, activeUserService)) - .setControllerAdvice(new ControllerExceptionHandler()) - .build(); - - lenient().when(activeUserService.getActiveUser(any())) - .thenReturn(new UserDTO("user", "User", "user@example.org", "subject", true)); - } - - // ------------------------------------------------------------------ happy path - - @Test - void listsTheActiveUsersFolders() throws Exception { - when(service.getFolders(any(), any(Logger.class))) - .thenReturn(new ExperimentFoldersDTO(List.of(folderDto()))); - - mvc.perform(get("/experiment-folders").principal(principal)) - .andExpect(status().isOk()) - .andExpect(content().contentTypeCompatibleWith("application/json")) - .andExpect(jsonPath("$.folders[0].id").value(FOLDER_ID)) - .andExpect(jsonPath("$.folders[0].name").value("My analysis set")) - .andExpect(jsonPath("$.folders[0].experimentIds[0]").value(RUN_ID)) - .andExpect(jsonPath("$.folders[0].sets[0].id").value(SET_ID)) - .andExpect(jsonPath("$.folders[0].sets[0].experimentIds[0]").value(RUN_ID)); - } - - @Test - void createsAFolderFromNameOnlyAndAnswersCreated() throws Exception { - when(service.createFolder(any(), any(CreateExperimentGroupDTO.class), any(Logger.class))) - .thenReturn(new ExperimentFolderDTO(FOLDER_ID, "My analysis set", List.of(), List.of())); - - mvc.perform(post("/experiment-folders").contentType("application/json").content("{\"name\":\"My analysis set\"}").principal(principal)) - .andExpect(status().isCreated()) - .andExpect(jsonPath("$.id").value(FOLDER_ID)) - .andExpect(jsonPath("$.experimentIds").isArray()) - .andExpect(jsonPath("$.sets").isArray()); - } - - @Test - void createFolderCarriesTheFirstRunUnderTheContractFieldName() throws Exception { - when(service.createFolder(any(), any(CreateExperimentGroupDTO.class), any(Logger.class))) - .thenReturn(folderDto()); - - mvc.perform(post("/experiment-folders").contentType("application/json") - .content("{\"name\":\"My analysis set\",\"experimentUuid\":\"" + RUN_ID + "\"}").principal(principal)) - .andExpect(status().isCreated()); - - ArgumentCaptor body = ArgumentCaptor.forClass(CreateExperimentGroupDTO.class); - verify(service).createFolder(eq(principal), body.capture(), any(Logger.class)); - assertThat(body.getValue().name()).isEqualTo("My analysis set"); - assertThat(body.getValue().experimentUuid()).isEqualTo(RUN_ID); - } - - @Test - void addMemberCarriesTheRunUnderTheContractFieldName() throws Exception { - when(service.addExperiment(any(), eq(FOLDER_ID), any(AddExperimentFoldersMemberDTO.class), any(Logger.class))) - .thenReturn(folderDto()); - - mvc.perform(post("/experiment-folders/" + FOLDER_ID + "/members").contentType("application/json") - .content("{\"experimentUuid\":\"" + RUN_ID + "\"}").principal(principal)) - .andExpect(status().isOk()) - .andExpect(jsonPath("$.id").value(FOLDER_ID)); - - ArgumentCaptor body = ArgumentCaptor.forClass(AddExperimentFoldersMemberDTO.class); - verify(service).addExperiment(eq(principal), eq(FOLDER_ID), body.capture(), any(Logger.class)); - assertThat(body.getValue().experimentUuid()).isEqualTo(RUN_ID); - } - - @Test - void setMembershipCarriesTheSetUnderTheContractFieldName() throws Exception { - when(service.updateSetMembership(any(), eq(FOLDER_ID), eq(RUN_ID), any(UpdateExperimentSetMembershipDTO.class), - any(Logger.class))).thenReturn(folderDto()); - - mvc.perform(patch("/experiment-folders/" + FOLDER_ID + "/members/" + RUN_ID + "/set") - .contentType("application/json").content("{\"setId\":\"" + SET_ID + "\"}").principal(principal)) - .andExpect(status().isOk()); - - ArgumentCaptor body = - ArgumentCaptor.forClass(UpdateExperimentSetMembershipDTO.class); - verify(service).updateSetMembership(eq(principal), eq(FOLDER_ID), eq(RUN_ID), body.capture(), any(Logger.class)); - assertThat(body.getValue().setId()).isEqualTo(SET_ID); - } - - @Test - void setMembershipWithoutASetReachesTheServiceAsUngroup() throws Exception { - when(service.updateSetMembership(any(), eq(FOLDER_ID), eq(RUN_ID), any(UpdateExperimentSetMembershipDTO.class), - any(Logger.class))).thenReturn(folderDto()); - - mvc.perform(patch("/experiment-folders/" + FOLDER_ID + "/members/" + RUN_ID + "/set") - .contentType("application/json").content("{\"setId\":null}").principal(principal)) - .andExpect(status().isOk()); - - ArgumentCaptor body = - ArgumentCaptor.forClass(UpdateExperimentSetMembershipDTO.class); - verify(service).updateSetMembership(eq(principal), eq(FOLDER_ID), eq(RUN_ID), body.capture(), any(Logger.class)); - assertThat(body.getValue().setId()).isNull(); - } - - @Test - void createSetCarriesItsOptionalSeedRun() throws Exception { - when(service.createSet(any(), eq(FOLDER_ID), any(CreateExperimentGroupDTO.class), any(Logger.class))) - .thenReturn(folderDto()); - - mvc.perform(post("/experiment-folders/" + FOLDER_ID + "/sets").contentType("application/json") - .content("{\"name\":\"Drug arm A\",\"experimentUuid\":\"" + RUN_ID + "\"}").principal(principal)) - .andExpect(status().isCreated()); - - ArgumentCaptor body = ArgumentCaptor.forClass(CreateExperimentGroupDTO.class); - verify(service).createSet(eq(principal), eq(FOLDER_ID), body.capture(), any(Logger.class)); - assertThat(body.getValue().name()).isEqualTo("Drug arm A"); - assertThat(body.getValue().experimentUuid()).isEqualTo(RUN_ID); - } - - @Test - void renamesAFolderAndASet() throws Exception { - when(service.renameFolder(any(), eq(FOLDER_ID), any(RenameExperimentGroupDTO.class), any(Logger.class))) - .thenReturn(folderDto()); - when(service.renameSet(any(), eq(FOLDER_ID), eq(SET_ID), any(RenameExperimentGroupDTO.class), any(Logger.class))) - .thenReturn(folderDto()); - - mvc.perform(patch("/experiment-folders/" + FOLDER_ID).contentType("application/json") - .content("{\"name\":\"Renamed\"}").principal(principal)).andExpect(status().isOk()); - mvc.perform(patch("/experiment-folders/" + FOLDER_ID + "/sets/" + SET_ID).contentType("application/json") - .content("{\"name\":\"Renamed set\"}").principal(principal)).andExpect(status().isOk()); - } - - // ------------------------------------------------------------------ deletes - - @Test - void deletingTheFolderLeavesNothingToReturn() throws Exception { - mvc.perform(delete("/experiment-folders/" + FOLDER_ID).principal(principal)) - .andExpect(status().isNoContent()) - .andExpect(content().string("")); - } - - /** Losing a member or a set changes what is left, so those two answer with the remaining folder. */ - @Test - void deletingAMemberOrASetAnswersWithTheUpdatedFolder() throws Exception { - when(service.removeExperiment(any(), eq(FOLDER_ID), eq(RUN_ID), any(Logger.class))).thenReturn(folderDto()); - when(service.deleteSet(any(), eq(FOLDER_ID), eq(SET_ID), any(Logger.class))).thenReturn(folderDto()); - - mvc.perform(delete("/experiment-folders/" + FOLDER_ID + "/members/" + RUN_ID).principal(principal)) - .andExpect(status().isOk()) - .andExpect(jsonPath("$.id").value(FOLDER_ID)) - .andExpect(jsonPath("$.sets[0].id").value(SET_ID)); - - mvc.perform(delete("/experiment-folders/" + FOLDER_ID + "/sets/" + SET_ID).principal(principal)) - .andExpect(status().isOk()) - .andExpect(jsonPath("$.experimentIds[0]").value(RUN_ID)); - } - - // ------------------------------------------------------------------ failures - - @Test - void blankNameIsABadRequest() throws Exception { - when(service.createFolder(any(), any(CreateExperimentGroupDTO.class), any(Logger.class))) - .thenThrow(new BadRequestException("Folder name must not be blank.")); - - mvc.perform(post("/experiment-folders").contentType("application/json").content("{\"name\":\" \"}").principal(principal)) - .andExpect(status().isBadRequest()) - .andExpect(jsonPath("$.statusCode").value(400)) - .andExpect(jsonPath("$.message").value("Folder name must not be blank.")); - } - - @Test - void malformedIdIsABadRequest() throws Exception { - when(service.getFolder(any(), eq("not-a-uuid"), any(Logger.class))) - .thenThrow(new BadRequestException("Invalid folderId: not-a-uuid")); - - mvc.perform(get("/experiment-folders/not-a-uuid").principal(principal)) - .andExpect(status().isBadRequest()) - .andExpect(jsonPath("$.statusCode").value(400)); - } - - @Test - void duplicateNamesAreAConflict() throws Exception { - when(service.createFolder(any(), any(CreateExperimentGroupDTO.class), any(Logger.class))) - .thenThrow(new ConflictException("An experiment folder named 'My analysis set' already exists.")); - when(service.createSet(any(), eq(FOLDER_ID), any(CreateExperimentGroupDTO.class), any(Logger.class))) - .thenThrow(new ConflictException("An experiment set named 'Drug arm A' already exists in this folder.")); - - mvc.perform(post("/experiment-folders").contentType("application/json").content("{\"name\":\"My analysis set\"}").principal(principal)) - .andExpect(status().isConflict()) - .andExpect(jsonPath("$.statusCode").value(409)); - mvc.perform(post("/experiment-folders/" + FOLDER_ID + "/sets").contentType("application/json") - .content("{\"name\":\"Drug arm A\"}").principal(principal)) - .andExpect(status().isConflict()) - .andExpect(jsonPath("$.statusCode").value(409)); - } - - @Test - void foreignFoldersAndForeignSetsAreBothNotFound() throws Exception { - when(service.getFolder(any(), eq(FOLDER_ID), any(Logger.class))) - .thenThrow(new ExperimentNotFoundException("Experiment folder with id : " + FOLDER_ID - + " was not found for the active user.")); - when(service.renameSet(any(), eq(FOLDER_ID), eq(SET_ID), any(RenameExperimentGroupDTO.class), any(Logger.class))) - .thenThrow(new ExperimentNotFoundException("Experiment set with id : " + SET_ID - + " was not found in folder : " + FOLDER_ID)); - - mvc.perform(get("/experiment-folders/" + FOLDER_ID).principal(principal)) - .andExpect(status().isNotFound()) - .andExpect(jsonPath("$.statusCode").value(404)); - mvc.perform(patch("/experiment-folders/" + FOLDER_ID + "/sets/" + SET_ID).contentType("application/json") - .content("{\"name\":\"whatever\"}").principal(principal)) - .andExpect(status().isNotFound()) - .andExpect(jsonPath("$.statusCode").value(404)); - } - - /** A run the caller may not read must not become a folder membership, and must not say 404 either. */ - @Test - void unreadableRunIsForbidden() throws Exception { - when(service.addExperiment(any(), eq(FOLDER_ID), any(AddExperimentFoldersMemberDTO.class), any(Logger.class))) - .thenThrow(new UnauthorizedException("You don't have access to that experiment.")); - - mvc.perform(post("/experiment-folders/" + FOLDER_ID + "/members").contentType("application/json") - .content("{\"experimentUuid\":\"" + RUN_ID + "\"}").principal(principal)) - .andExpect(status().isForbidden()) - .andExpect(jsonPath("$.statusCode").value(403)); - } - - private ExperimentFolderDTO folderDto() { - return new ExperimentFolderDTO(FOLDER_ID, "My analysis set", List.of(RUN_ID), - List.of(new ExperimentSetDTO(SET_ID, "Drug arm A", List.of(RUN_ID)))); - } -} diff --git a/src/test/java/hbp/mip/folder/ExperimentFolderDTOTest.java b/src/test/java/hbp/mip/folder/ExperimentFolderDTOTest.java deleted file mode 100644 index cffef3e3c..000000000 --- a/src/test/java/hbp/mip/folder/ExperimentFolderDTOTest.java +++ /dev/null @@ -1,85 +0,0 @@ -package hbp.mip.folder; - -import hbp.mip.experiment.ExperimentDAO; -import hbp.mip.user.UserDAO; -import org.junit.jupiter.api.Test; - -import java.util.List; -import java.util.UUID; - -import static org.assertj.core.api.Assertions.assertThat; - -/** - * The mapping is the contract: three orderings have to survive the trip from the position columns to - * the arrays the dashboard renders, and an empty folder has to answer with empty arrays rather than - * nulls (null fields are dropped from the JSON, which would break `folder.sets.map(...)`). - */ -class ExperimentFolderDTOTest { - - @Test - void mapsMembersSetsAndSetMembersToTheirStoredOrder() { - ExperimentFolderDAO folder = new ExperimentFolderDAO( - new UserDAO("user", "User", "user@example.org", "subject"), "My analysis set", 1); - - ExperimentSetDAO first = new ExperimentSetDAO(folder, "First", 1); - ExperimentSetDAO second = new ExperimentSetDAO(folder, "Second", 2); - folder.getSets().add(second); - folder.getSets().add(first); - - UUID inFirstLow = uuid(); - UUID inFirstHigh = uuid(); - UUID ungrouped = uuid(); - UUID lateUngrouped = uuid(); - - // Added out of order on purpose: the response must follow the position columns, not insertion. - folder.getMembers().add(member(folder, inFirstHigh, first, 3, 2)); - folder.getMembers().add(member(folder, ungrouped, null, 1, null)); - folder.getMembers().add(member(folder, inFirstLow, second, 2, 1)); - folder.getMembers().add(member(folder, lateUngrouped, null, null, null)); - folder.getMembers().get(2).setExperimentSet(first); - - var dto = ExperimentFolderDTO.from(folder); - - assertThat(dto.id()).isEqualTo(folder.getId().toString()); - assertThat(dto.name()).isEqualTo("My analysis set"); - assertThat(dto.experimentIds()).containsExactly(ungrouped.toString(), inFirstLow.toString(), - inFirstHigh.toString(), lateUngrouped.toString()); - - assertThat(dto.sets()).extracting(ExperimentSetDTO::name).containsExactly("First", "Second"); - assertThat(dto.sets().get(0).id()).isEqualTo(first.getId().toString()); - assertThat(dto.sets().get(0).experimentIds()) - .containsExactly(inFirstLow.toString(), inFirstHigh.toString()); - assertThat(dto.sets().get(1).experimentIds()).isEmpty(); - } - - @Test - void mapsAFreshFolderToEmptyArrays() { - ExperimentFolderDAO folder = new ExperimentFolderDAO( - new UserDAO("user", "User", "user@example.org", "subject"), "Empty", 1); - - var dto = ExperimentFolderDTO.from(folder); - var collection = ExperimentFoldersDTO.from(List.of(folder)); - - assertThat(dto.experimentIds()).isEmpty(); - assertThat(dto.sets()).isEmpty(); - assertThat(collection.folders()).singleElement().satisfies(folderDto -> { - assertThat(folderDto.experimentIds()).isEmpty(); - assertThat(folderDto.sets()).isEmpty(); - }); - } - - private ExperimentFolderMemberDAO member(ExperimentFolderDAO folder, UUID experimentUuid, ExperimentSetDAO set, - Integer folderPosition, Integer setPosition) { - ExperimentDAO experiment = new ExperimentDAO(); - experiment.setUuid(experimentUuid); - - ExperimentFolderMemberDAO member = new ExperimentFolderMemberDAO(folder, experiment, folderPosition); - member.setExperimentSet(set); - member.setSetPosition(setPosition); - return member; - } - - private UUID uuid() { - return UUID.randomUUID(); - } -} diff --git a/src/test/java/hbp/mip/folder/ExperimentFolderServiceTest.java b/src/test/java/hbp/mip/folder/ExperimentFolderServiceTest.java deleted file mode 100644 index cd54af9e6..000000000 --- a/src/test/java/hbp/mip/folder/ExperimentFolderServiceTest.java +++ /dev/null @@ -1,659 +0,0 @@ -package hbp.mip.folder; - -import hbp.mip.experiment.ExperimentDAO; -import hbp.mip.experiment.ExperimentService; -import hbp.mip.user.ActiveUserService; -import hbp.mip.user.UserDAO; -import hbp.mip.user.UserDTO; -import hbp.mip.utils.Exceptions.BadRequestException; -import hbp.mip.utils.Exceptions.ConflictException; -import hbp.mip.utils.Exceptions.ExperimentNotFoundException; -import hbp.mip.utils.Exceptions.UnauthorizedException; -import hbp.mip.utils.Logger; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.ArgumentCaptor; -import org.mockito.Mock; -import org.mockito.junit.jupiter.MockitoExtension; -import org.springframework.dao.DataIntegrityViolationException; -import org.springframework.security.core.Authentication; - -import java.sql.SQLException; -import java.util.List; -import java.util.Optional; -import java.util.UUID; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; -import static org.mockito.ArgumentMatchers.any; -import static org.mockito.ArgumentMatchers.eq; -import static org.mockito.Mockito.lenient; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -@ExtendWith(MockitoExtension.class) -class ExperimentFolderServiceTest { - - private static final String USERNAME = "user"; - - @Mock - private ActiveUserService activeUserService; - - @Mock - private ExperimentFolderRepository folderRepository; - - @Mock - private ExperimentService experimentService; - - @Mock - private Authentication authentication; - - private ExperimentFolderService service; - - private final UserDTO user = new UserDTO(USERNAME, "User", "user@example.org", "subject", true); - private final Logger logger = new Logger(USERNAME, "test"); - - @BeforeEach - void setUp() { - service = new ExperimentFolderService(activeUserService, folderRepository, experimentService); - - lenient().when(activeUserService.getActiveUser(authentication)).thenReturn(user); - lenient().when(folderRepository.saveAndFlush(any(ExperimentFolderDAO.class))) - .thenAnswer(invocation -> invocation.getArgument(0)); - } - - // ------------------------------------------------------------------ folders - - @Test - void createFolder_collapsesWhitespaceAndPlacesItLast() { - givenOwnedFolders(folder("Existing", 7)); - - var created = service.createFolder(authentication, new CreateExperimentGroupDTO(" My Analysis Set ", null), - logger); - - ArgumentCaptor saved = ArgumentCaptor.forClass(ExperimentFolderDAO.class); - verify(folderRepository).saveAndFlush(saved.capture()); - assertThat(created.name()).isEqualTo("My Analysis Set"); - assertThat(saved.getValue().getSortOrder()).isEqualTo(8); - assertThat(created.experimentIds()).isEmpty(); - assertThat(created.sets()).isEmpty(); - } - - @Test - void createFolder_capsTheNameAtTheLengthTheFrontendAllows() { - givenOwnedFolders(); - - var created = service.createFolder(authentication, - new CreateExperimentGroupDTO(" " + "a".repeat(80) + " ", null), logger); - - assertThat(created.name()).hasSize(ExperimentFolderService.MAX_NAME_LENGTH); - } - - @Test - void createFolder_rejectsANameThatIsOnlyWhitespace() { - assertThatThrownBy(() -> service.createFolder(authentication, new CreateExperimentGroupDTO(" \t\n ", null), logger)) - .isInstanceOf(BadRequestException.class); - - verify(folderRepository, never()).saveAndFlush(any(ExperimentFolderDAO.class)); - } - - @Test - void createFolder_rejectsANameAlreadyTakenIgnoringCase() { - givenOwnedFolders(folder("My Analysis Set", 1)); - - assertThatThrownBy(() -> service.createFolder(authentication, - new CreateExperimentGroupDTO(" my analysis set ", null), logger)) - .isInstanceOf(ConflictException.class); - - verify(folderRepository, never()).saveAndFlush(any(ExperimentFolderDAO.class)); - } - - @Test - void renameFolder_rejectsSomebodyElsesFolderAsNotFound() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", "somebody-else"); - - assertThatThrownBy(() -> service.renameFolder(authentication, folderId.toString(), - new RenameExperimentGroupDTO("Taken By Me"), logger)) - .isInstanceOf(ExperimentNotFoundException.class); - } - - @Test - void renameFolder_keepsItsOwnNameAsNoConflict() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO owned = givenFolder(folderId, "My Set", USERNAME); - givenOwnedFolders(owned); - - var renamed = service.renameFolder(authentication, folderId.toString(), - new RenameExperimentGroupDTO(" my set "), logger); - - assertThat(renamed.name()).isEqualTo("my set"); - } - - @Test - void getFolder_readsOnlyTheFoldersOfTheActiveUser() { - // The repository query is already owner scoped; findById is the one that must not leak either. - UUID mine = UUID.randomUUID(); - givenFolder(mine, "Mine", USERNAME); - - assertThat(service.getFolder(authentication, mine.toString(), logger).name()).isEqualTo("Mine"); - } - - @Test - void getFolder_hidesAFolderOwnedByAnotherUserBehindNotFound() { - UUID foreign = UUID.randomUUID(); - givenFolder(foreign, "Theirs", "somebody-else"); - - assertThatThrownBy(() -> service.getFolder(authentication, foreign.toString(), logger)) - .isInstanceOf(ExperimentNotFoundException.class); - } - - @Test - void getFolder_rejectsAnIdThatIsNotAnId() { - assertThatThrownBy(() -> service.getFolder(authentication, "not-a-uuid", logger)) - .isInstanceOf(BadRequestException.class); - } - - // ------------------------------------------------------------------ members - - @Test - void addExperiment_checksTheRunIsReadableAndAppendsItLast() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - ExperimentDAO experiment = experiment(); - givenReadableExperiment(experiment); - - var updated = service.addExperiment(authentication, folderId.toString(), - new AddExperimentFoldersMemberDTO(experiment.getUuid().toString()), logger); - - verify(experimentService).assertExperimentAccessible(eq(authentication), eq(experiment.getUuid().toString()), - any(Logger.class)); - assertThat(updated.experimentIds()).containsExactly(experiment.getUuid().toString()); - - ArgumentCaptor saved = ArgumentCaptor.forClass(ExperimentFolderDAO.class); - verify(folderRepository).saveAndFlush(saved.capture()); - assertThat(saved.getValue().getMembers()).singleElement() - .satisfies(member -> assertThat(member.getFolderPosition()).isEqualTo(1)); - } - - @Test - void addExperiment_isIdempotentForARunTheFolderAlreadyHolds() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentDAO experiment = experiment(); - givenReadableExperiment(experiment); - folder.getMembers().add(new ExperimentFolderMemberDAO(folder, experiment, 1)); - - var again = service.addExperiment(authentication, folderId.toString(), - new AddExperimentFoldersMemberDTO(experiment.getUuid().toString()), logger); - - assertThat(again.experimentIds()).containsExactly(experiment.getUuid().toString()); - assertThat(folder.getMembers()).hasSize(1); - verify(folderRepository, never()).saveAndFlush(any(ExperimentFolderDAO.class)); - } - - @Test - void addExperiment_refusesARunTheUserMayNotRead() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - ExperimentDAO hidden = experiment(); - when(experimentService.assertExperimentAccessible(eq(authentication), eq(hidden.getUuid().toString()), - any(Logger.class))) - .thenThrow(new UnauthorizedException("You don't have access to that experiment.")); - - assertThatThrownBy(() -> service.addExperiment(authentication, folderId.toString(), - new AddExperimentFoldersMemberDTO(hidden.getUuid().toString()), logger)) - .isInstanceOf(UnauthorizedException.class); - - verify(folderRepository, never()).saveAndFlush(any(ExperimentFolderDAO.class)); - } - - @Test - void addExperiment_requiresAnExperimentId() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - - assertThatThrownBy(() -> service.addExperiment(authentication, folderId.toString(), - new AddExperimentFoldersMemberDTO(" "), logger)) - .isInstanceOf(BadRequestException.class); - } - - @Test - void removeExperiment_dropsTheRunFromTheFolderAndItsSets() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO set = new ExperimentSetDAO(folder, "Baseline", 1); - folder.getSets().add(set); - ExperimentDAO first = experiment(); - ExperimentDAO second = experiment(); - ExperimentFolderMemberDAO firstMember = new ExperimentFolderMemberDAO(folder, first, 1); - firstMember.setExperimentSet(set); - firstMember.setSetPosition(1); - folder.getMembers().add(firstMember); - folder.getMembers().add(new ExperimentFolderMemberDAO(folder, second, 2)); - - var after = service.removeExperiment(authentication, folderId.toString(), first.getUuid().toString(), logger); - assertThat(after.experimentIds()).containsExactly(second.getUuid().toString()); - assertThat(after.sets()).singleElement().satisfies(candidate -> - assertThat(candidate.experimentIds()).isEmpty()); - } - - @Test - void removeExperiment_isHarmlessWhenTheRunIsNotInFolder() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - - service.removeExperiment(authentication, folderId.toString(), experiment().getUuid().toString(), logger); - - verify(folderRepository, never()).saveAndFlush(any(ExperimentFolderDAO.class)); - } - - // ------------------------------------------------------------------ sets - - @Test - void createSet_appendsTheSetAndCanSeedItWithAMember() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - folder.getSets().add(new ExperimentSetDAO(folder, "Baseline", 4)); - ExperimentDAO experiment = experiment(); - givenReadableExperiment(experiment); - - var updated = service.createSet(authentication, folderId.toString(), - new CreateExperimentGroupDTO(" Drug arm A ", experiment.getUuid().toString()), logger); - - assertThat(updated.sets()).extracting(ExperimentSetDTO::name).containsExactly("Baseline", "Drug arm A"); - assertThat(updated.sets().get(1).experimentIds()).containsExactly(experiment.getUuid().toString()); - assertThat(folder.getMembers()).singleElement().satisfies(member -> { - assertThat(member.getFolderPosition()).isEqualTo(1); - assertThat(member.getSetPosition()).isEqualTo(1); - }); - } - - @Test - void createSet_rejectsASetNameAlreadyTakenIgnoringCase() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - folder.getSets().add(new ExperimentSetDAO(folder, "Drug arm A", 1)); - - assertThatThrownBy(() -> service.createSet(authentication, folderId.toString(), - new CreateExperimentGroupDTO(" drug ARM a ", null), logger)) - .isInstanceOf(ConflictException.class); - } - - @Test - void createSet_mayShareTheNameOfItsOwnFolder() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - - var updated = service.createSet(authentication, folderId.toString(), - new CreateExperimentGroupDTO("my set", null), logger); - - assertThat(updated.sets()).singleElement().satisfies(set -> assertThat(set.name()).isEqualTo("my set")); - } - - @Test - void updateSetMembership_movesTheRunOutOfThePreviousSet() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO baseline = new ExperimentSetDAO(folder, "Baseline", 1); - ExperimentSetDAO armA = new ExperimentSetDAO(folder, "Drug arm A", 2); - folder.getSets().add(baseline); - folder.getSets().add(armA); - ExperimentDAO moved = experiment(); - ExperimentFolderMemberDAO member = new ExperimentFolderMemberDAO(folder, moved, 1); - member.setExperimentSet(baseline); - member.setSetPosition(3); - folder.getMembers().add(member); - - var updated = service.updateSetMembership(authentication, folderId.toString(), moved.getUuid().toString(), - new UpdateExperimentSetMembershipDTO(armA.getId().toString()), logger); - - assertThat(updated.sets()).filteredOn(set -> set.name().equals("Baseline")) - .singleElement().satisfies(set -> assertThat(set.experimentIds()).isEmpty()); - assertThat(updated.sets()).filteredOn(set -> set.name().equals("Drug arm A")) - .singleElement().satisfies(set -> assertThat(set.experimentIds()) - .containsExactly(moved.getUuid().toString())); - assertThat(member.getExperimentSet()).isSameAs(armA); - assertThat(member.getSetPosition()).isEqualTo(1); - } - - @Test - void updateSetMembership_createsTheMembershipWhenTheRunIsNotInFolderYet() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO armA = new ExperimentSetDAO(folder, "Drug arm A", 1); - folder.getSets().add(armA); - ExperimentDAO experiment = experiment(); - givenReadableExperiment(experiment); - - var updated = service.updateSetMembership(authentication, folderId.toString(), experiment.getUuid().toString(), - new UpdateExperimentSetMembershipDTO(armA.getId().toString()), logger); - - verify(experimentService).assertExperimentAccessible(eq(authentication), eq(experiment.getUuid().toString()), - any(Logger.class)); - assertThat(updated.experimentIds()).containsExactly(experiment.getUuid().toString()); - assertThat(updated.sets()).singleElement().satisfies(set -> - assertThat(set.experimentIds()).containsExactly(experiment.getUuid().toString())); - } - - @Test - void updateSetMembership_withoutASetLeavesTheRunInTheFolderUngrouped() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO armA = new ExperimentSetDAO(folder, "Drug arm A", 1); - folder.getSets().add(armA); - ExperimentDAO experiment = experiment(); - ExperimentFolderMemberDAO member = new ExperimentFolderMemberDAO(folder, experiment, 1); - member.setExperimentSet(armA); - member.setSetPosition(1); - folder.getMembers().add(member); - - var updated = service.updateSetMembership(authentication, folderId.toString(), experiment.getUuid().toString(), - new UpdateExperimentSetMembershipDTO(null), logger); - - assertThat(updated.experimentIds()).containsExactly(experiment.getUuid().toString()); - assertThat(updated.sets()).singleElement().satisfies(set -> assertThat(set.experimentIds()).isEmpty()); - assertThat(member.getExperimentSet()).isNull(); - assertThat(member.getSetPosition()).isNull(); - } - - @Test - void updateSetMembership_rejectsASetOfAnotherFolder() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - - assertThatThrownBy(() -> service.updateSetMembership(authentication, folderId.toString(), - experiment().getUuid().toString(), new UpdateExperimentSetMembershipDTO(UUID.randomUUID().toString()), - logger)) - .isInstanceOf(ExperimentNotFoundException.class); - } - - @Test - void renameSet_renamesOnlyItsOwnSet() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO armA = new ExperimentSetDAO(folder, "Drug arm A", 1); - folder.getSets().add(armA); - - var updated = service.renameSet(authentication, folderId.toString(), armA.getId().toString(), - new RenameExperimentGroupDTO(" Drug arm B "), logger); - - assertThat(updated.sets()).singleElement().satisfies(set -> assertThat(set.name()).isEqualTo("Drug arm B")); - } - - @Test - void renameSet_rejectsANameAnotherSetAlreadyHas() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - folder.getSets().add(new ExperimentSetDAO(folder, "Drug arm A", 1)); - ExperimentSetDAO armB = new ExperimentSetDAO(folder, "Drug arm B", 2); - folder.getSets().add(armB); - - assertThatThrownBy(() -> service.renameSet(authentication, folderId.toString(), armB.getId().toString(), - new RenameExperimentGroupDTO("drug arm a"), logger)) - .isInstanceOf(ConflictException.class); - } - - @Test - void deleteSet_leavesItsRunsInTheFolderUngrouped() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO armA = new ExperimentSetDAO(folder, "Drug arm A", 1); - folder.getSets().add(armA); - ExperimentDAO first = experiment(); - ExperimentDAO second = experiment(); - for (ExperimentDAO run : List.of(first, second)) { - ExperimentFolderMemberDAO member = new ExperimentFolderMemberDAO(folder, run, 1); - member.setExperimentSet(armA); - member.setSetPosition(1); - folder.getMembers().add(member); - } - - var after = service.deleteSet(authentication, folderId.toString(), armA.getId().toString(), logger); - assertThat(after.sets()).isEmpty(); - assertThat(after.experimentIds()).containsExactly(first.getUuid().toString(), second.getUuid().toString()); - assertThat(folder.getMembers()).allSatisfy(member -> { - assertThat(member.getExperimentSet()).isNull(); - assertThat(member.getSetPosition()).isNull(); - }); - } - - @Test - void deleteFolder_removesTheFolderWithoutTouchingTheRuns() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - folder.getMembers().add(new ExperimentFolderMemberDAO(folder, experiment(), 1)); - - service.deleteFolder(authentication, folderId.toString(), logger); - - ArgumentCaptor deleted = ArgumentCaptor.forClass(ExperimentFolderDAO.class); - - verify(folderRepository).delete(deleted.capture()); - assertThat(deleted.getValue().getId()).isEqualTo(folderId); - } - - // ------------------------------------------------------------------ ordering - - @Test - void positionsKeepGrowingFromWhateverTheFolderAlreadyHolds() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO armA = new ExperimentSetDAO(folder, "Drug arm A", 5); - folder.getSets().add(armA); - ExperimentDAO first = experiment(); - ExperimentDAO second = experiment(); - ExperimentDAO third = experiment(); - givenReadableExperiment(first, second, third); - ExperimentFolderMemberDAO firstMember = new ExperimentFolderMemberDAO(folder, first, 4); - firstMember.setExperimentSet(armA); - firstMember.setSetPosition(2); - folder.getMembers().add(firstMember); - - service.addExperiment(authentication, folderId.toString(), - new AddExperimentFoldersMemberDTO(second.getUuid().toString()), logger); - service.updateSetMembership(authentication, folderId.toString(), third.getUuid().toString(), - new UpdateExperimentSetMembershipDTO(armA.getId().toString()), logger); - - assertThat(folder.getMembers()).extracting(ExperimentFolderMemberDAO::getFolderPosition) - .containsExactly(4, 5, 6); - assertThat(folder.getMembers()).filteredOn(member -> first.getUuid().equals(member.getExperiment().getUuid())) - .singleElement().satisfies(member -> assertThat(member.getSetPosition()).isEqualTo(2)); - assertThat(ExperimentFolderDTO.from(folder).experimentIds()) - .containsExactly(first.getUuid().toString(), second.getUuid().toString(), - third.getUuid().toString()); - } - - @Test - void getFolders_returnsEveryFolderOfTheActiveUserInOrder() { - ExperimentFolderDAO first = folder("First", 1); - ExperimentFolderDAO second = folder("Second", 2); - givenOwnedFolders(first, second); - - var folders = service.getFolders(authentication, logger); - - assertThat(folders.folders()).extracting(ExperimentFolderDTO::name).containsExactly("First", "Second"); - } - - @Test - void getFolders_answersAnEmptyListInsteadOfANotFound() { - givenOwnedFolders(); - - assertThat(service.getFolders(authentication, logger).folders()).isEmpty(); - } - - // ------------------------------------------------------------------ create folder with its first run - - @Test - void createFolder_canSeedItWithTheRunTheGestureStartedFrom() { - givenOwnedFolders(); - ExperimentDAO experiment = experiment(); - givenReadableExperiment(experiment); - - var created = service.createFolder(authentication, - new CreateExperimentGroupDTO("New folder", experiment.getUuid().toString()), logger); - - verify(experimentService).assertExperimentAccessible(eq(authentication), eq(experiment.getUuid().toString()), - any(Logger.class)); - assertThat(created.experimentIds()).containsExactly(experiment.getUuid().toString()); - - ArgumentCaptor saved = ArgumentCaptor.forClass(ExperimentFolderDAO.class); - verify(folderRepository).saveAndFlush(saved.capture()); - assertThat(saved.getValue().getMembers()).singleElement().satisfies(member -> { - assertThat(member.getFolderPosition()).isEqualTo(1); - assertThat(member.getExperimentSet()).isNull(); - }); - } - - @Test - void createFolder_writesNothingWhenTheSeedRunIsNotReadable() { - givenOwnedFolders(); - ExperimentDAO hidden = experiment(); - when(experimentService.assertExperimentAccessible(eq(authentication), eq(hidden.getUuid().toString()), - any(Logger.class))).thenThrow(new UnauthorizedException("You don't have access to that experiment.")); - - assertThatThrownBy(() -> service.createFolder(authentication, - new CreateExperimentGroupDTO("New folder", hidden.getUuid().toString()), logger)) - .isInstanceOf(UnauthorizedException.class); - - verify(folderRepository, never()).saveAndFlush(any(ExperimentFolderDAO.class)); - } - - // ------------------------------------------------------------------ lost uniqueness races - - @Test - void aLostNameRaceInDatabaseAnswersConflictNotInternalError() { - givenOwnedFolders(); - when(folderRepository.saveAndFlush(any(ExperimentFolderDAO.class))) - .thenThrow(new DataIntegrityViolationException("could not execute statement", - new SQLException("duplicate key value violates unique constraint", "23505"))); - - assertThatThrownBy(() -> service.createFolder(authentication, - new CreateExperimentGroupDTO("Nobody saw the other tab", null), logger)) - .isInstanceOf(ConflictException.class); - } - - @Test - void aLostSetNameRaceInDatabaseAnswersConflictNotInternalError() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - when(folderRepository.saveAndFlush(any(ExperimentFolderDAO.class))) - .thenThrow(new DataIntegrityViolationException("Batch entry rejected", - new SQLException("duplicate key", "23505"))); - - assertThatThrownBy(() -> service.createSet(authentication, folderId.toString(), - new CreateExperimentGroupDTO("Arm A", null), logger)) - .isInstanceOf(ConflictException.class); - } - - @Test - void anIntegrityFailureThatIsNotUniquenessIsNotRelabelledAsConflict() { - givenOwnedFolders(); - when(folderRepository.saveAndFlush(any(ExperimentFolderDAO.class))) - .thenThrow(new DataIntegrityViolationException("could not execute statement", - new SQLException("null value in column \"name\" violates not-null constraint", "23502"))); - - assertThatThrownBy(() -> service.createFolder(authentication, - new CreateExperimentGroupDTO("Broken", null), logger)) - .isInstanceOf(DataIntegrityViolationException.class); - } - - // ------------------------------------------------------------------ per-folder write locking - - @Test - void memberAndSetWritesTakeTheFolderRowLock() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentSetDAO set = new ExperimentSetDAO(folder, "Arm A", 1); - folder.getSets().add(set); - ExperimentDAO first = experiment(); - ExperimentDAO second = experiment(); - givenReadableExperiment(first, second); - - service.addExperiment(authentication, folderId.toString(), - new AddExperimentFoldersMemberDTO(first.getUuid().toString()), logger); - service.updateSetMembership(authentication, folderId.toString(), first.getUuid().toString(), - new UpdateExperimentSetMembershipDTO(set.getId().toString()), logger); - service.updateSetMembership(authentication, folderId.toString(), first.getUuid().toString(), - new UpdateExperimentSetMembershipDTO(null), logger); - service.createSet(authentication, folderId.toString(), - new CreateExperimentGroupDTO("Arm B", second.getUuid().toString()), logger); - service.removeExperiment(authentication, folderId.toString(), second.getUuid().toString(), logger); - service.deleteSet(authentication, folderId.toString(), set.getId().toString(), logger); - - verify(folderRepository, times(6)).findByIdForUpdate(folderId); - verify(folderRepository, never()).findById(folderId); - } - - @Test - void readsDoNotTakeTheWriteLock() { - UUID folderId = UUID.randomUUID(); - givenFolder(folderId, "My Set", USERNAME); - - service.getFolder(authentication, folderId.toString(), logger); - - verify(folderRepository).findById(folderId); - verify(folderRepository, never()).findByIdForUpdate(folderId); - } - - /** - * The lock is what makes the pre-check see a competing writer: membership added before this call - * (whatever committed first) is honoured and the folder is returned unchanged. - */ - @Test - void addExperiment_underTheLockSeesAMembershipThatAlreadyCommitted() { - UUID folderId = UUID.randomUUID(); - ExperimentFolderDAO folder = givenFolder(folderId, "My Set", USERNAME); - ExperimentDAO experiment = experiment(); - givenReadableExperiment(experiment); - folder.getMembers().add(new ExperimentFolderMemberDAO(folder, experiment, 1)); - - var updated = service.addExperiment(authentication, folderId.toString(), - new AddExperimentFoldersMemberDTO(experiment.getUuid().toString()), logger); - - verify(folderRepository).findByIdForUpdate(folderId); - assertThat(updated.experimentIds()).containsExactly(experiment.getUuid().toString()); - verify(folderRepository, never()).saveAndFlush(any(ExperimentFolderDAO.class)); - } - - // ------------------------------------------------------------------ helpers - - private void givenOwnedFolders(ExperimentFolderDAO... folders) { - when(folderRepository.findOwnedFolders(USERNAME)).thenReturn(List.of(folders)); - } - - private ExperimentFolderDAO givenFolder(UUID folderId, String name, String ownerUsername) { - ExperimentFolderDAO folder = new ExperimentFolderDAO( - new UserDAO(ownerUsername, "User", "user@example.org", "subject"), name, 1); - folder.setId(folderId); - // Reads resolve through findById, member/set writes through the locked findByIdForUpdate; a test - // exercises one of them, so both stubs are lenient. - lenient().when(folderRepository.findById(folderId)).thenReturn(Optional.of(folder)); - lenient().when(folderRepository.findByIdForUpdate(folderId)).thenReturn(Optional.of(folder)); - return folder; - } - - private void givenReadableExperiment(ExperimentDAO... experiments) { - for (ExperimentDAO experiment : experiments) { - lenient().when(experimentService.assertExperimentAccessible(eq(authentication), - eq(experiment.getUuid().toString()), any(Logger.class))).thenReturn(experiment); - } - } - - private ExperimentFolderDAO folder(String name, int sortOrder) { - return new ExperimentFolderDAO(userOwner(), name, sortOrder); - } - - private UserDAO userOwner() { - return new UserDAO(USERNAME, "User", "user@example.org", "subject"); - } - - private ExperimentDAO experiment() { - ExperimentDAO experiment = new ExperimentDAO(); - experiment.setUuid(UUID.randomUUID()); - experiment.setName("run"); - return experiment; - } -} diff --git a/src/test/java/hbp/mip/study/StudyAPITest.java b/src/test/java/hbp/mip/study/StudyAPITest.java new file mode 100644 index 000000000..a414c7600 --- /dev/null +++ b/src/test/java/hbp/mip/study/StudyAPITest.java @@ -0,0 +1,301 @@ +package hbp.mip.study; + +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.ControllerExceptionHandler; +import hbp.mip.utils.Exceptions.BadRequestException; +import hbp.mip.utils.Exceptions.ConflictException; +import hbp.mip.utils.Exceptions.StudyNotFoundException; +import hbp.mip.utils.Exceptions.AnalysisGroupNotFoundException; +import hbp.mip.utils.Exceptions.UnauthorizedException; +import hbp.mip.utils.Logger; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; +import org.springframework.security.core.Authentication; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.patch; +import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +/** + * The contract, as a test. Body field names, response field names, and the status each failure answers + * with are what the frontend codes against, and none of them are covered by service unit tests: those + * call the service directly and never see Jackson or {@code ControllerExceptionHandler}. + * + * Standalone MockMvc on purpose — no security context, no datasource. The active user is the request + * principal, which is also how the real request reaches the controller. + */ +@ExtendWith(MockitoExtension.class) +class StudyAPITest { + + private static final String STUDY_ID = "11111111-1111-1111-1111-111111111111"; + private static final String GROUP_ID = "22222222-2222-2222-2222-222222222222"; + private static final String RUN_ID = "33333333-3333-3333-3333-333333333333"; + + @Mock + private StudyService service; + + @Mock + private ActiveUserService activeUserService; + + private final Authentication principal = new UsernamePasswordAuthenticationToken("user", null); + + private MockMvc mvc; + + @BeforeEach + void setUp() { + mvc = MockMvcBuilders + .standaloneSetup(new StudyAPI(service, activeUserService)) + .setControllerAdvice(new ControllerExceptionHandler()) + .build(); + + lenient().when(activeUserService.getActiveUser(any())) + .thenReturn(new UserDTO("user", "User", "user@example.org", "subject", true)); + } + + // ------------------------------------------------------------------ happy path + + @Test + void obsoleteRoutesAreUnavailable() throws Exception { + mvc.perform(get("/experiment-folders").principal(principal)).andExpect(status().isNotFound()); + mvc.perform(post("/studies/" + STUDY_ID + "/sets").principal(principal) + .contentType("application/json").content("{\"name\":\"Old route\"}")) + .andExpect(status().isNotFound()); + mvc.perform(patch("/studies/" + STUDY_ID + "/members/" + RUN_ID + "/set").principal(principal) + .contentType("application/json").content("{}")) + .andExpect(status().isNotFound()); + } + + @Test + void listsTheActiveUsersStudies() throws Exception { + when(service.getStudies(any(), any(Logger.class))) + .thenReturn(new StudiesDTO(List.of(studyDto()))); + + mvc.perform(get("/studies").principal(principal)) + .andExpect(status().isOk()) + .andExpect(content().contentTypeCompatibleWith("application/json")) + .andExpect(jsonPath("$.studies[0].id").value(STUDY_ID)) + .andExpect(jsonPath("$.studies[0].name").value("My analysis group")) + .andExpect(jsonPath("$.studies[0].analysisIds[0]").value(RUN_ID)) + .andExpect(jsonPath("$.studies[0].groups[0].id").value(GROUP_ID)) + .andExpect(jsonPath("$.studies[0].groups[0].analysisIds[0]").value(RUN_ID)); + } + + @Test + void createsAStudyFromNameOnlyAndAnswersCreated() throws Exception { + when(service.createStudy(any(), any(CreateStudyDTO.class), any(Logger.class))) + .thenReturn(new StudyDTO(STUDY_ID, "My analysis group", List.of(), List.of())); + + mvc.perform(post("/studies").contentType("application/json").content("{\"name\":\"My analysis group\"}").principal(principal)) + .andExpect(status().isCreated()) + .andExpect(jsonPath("$.id").value(STUDY_ID)) + .andExpect(jsonPath("$.analysisIds").isArray()) + .andExpect(jsonPath("$.groups").isArray()); + } + + @Test + void createStudyCarriesTheFirstRunUnderTheContractFieldName() throws Exception { + when(service.createStudy(any(), any(CreateStudyDTO.class), any(Logger.class))) + .thenReturn(studyDto()); + + mvc.perform(post("/studies").contentType("application/json") + .content("{\"name\":\"My analysis group\",\"analysisId\":\"" + RUN_ID + "\"}").principal(principal)) + .andExpect(status().isCreated()); + + ArgumentCaptor body = ArgumentCaptor.forClass(CreateStudyDTO.class); + verify(service).createStudy(eq(principal), body.capture(), any(Logger.class)); + assertThat(body.getValue().name()).isEqualTo("My analysis group"); + assertThat(body.getValue().analysisId()).isEqualTo(RUN_ID); + } + + @Test + void addMemberCarriesTheRunUnderTheContractFieldName() throws Exception { + when(service.addAnalysis(any(), eq(STUDY_ID), any(AddStudyMemberDTO.class), any(Logger.class))) + .thenReturn(studyDto()); + + mvc.perform(post("/studies/" + STUDY_ID + "/members").contentType("application/json") + .content("{\"analysisId\":\"" + RUN_ID + "\"}").principal(principal)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(STUDY_ID)); + + ArgumentCaptor body = ArgumentCaptor.forClass(AddStudyMemberDTO.class); + verify(service).addAnalysis(eq(principal), eq(STUDY_ID), body.capture(), any(Logger.class)); + assertThat(body.getValue().analysisId()).isEqualTo(RUN_ID); + } + + @Test + void groupMembershipCarriesTheGroupUnderTheContractFieldName() throws Exception { + when(service.updateGroupMembership(any(), eq(STUDY_ID), eq(RUN_ID), any(UpdateAnalysisGroupMembershipDTO.class), + any(Logger.class))).thenReturn(studyDto()); + + mvc.perform(patch("/studies/" + STUDY_ID + "/members/" + RUN_ID + "/group") + .contentType("application/json").content("{\"groupId\":\"" + GROUP_ID + "\"}").principal(principal)) + .andExpect(status().isOk()); + + ArgumentCaptor body = + ArgumentCaptor.forClass(UpdateAnalysisGroupMembershipDTO.class); + verify(service).updateGroupMembership(eq(principal), eq(STUDY_ID), eq(RUN_ID), body.capture(), any(Logger.class)); + assertThat(body.getValue().groupId()).isEqualTo(GROUP_ID); + } + + @Test + void groupMembershipWithoutAGroupReachesTheServiceAsUngroup() throws Exception { + when(service.updateGroupMembership(any(), eq(STUDY_ID), eq(RUN_ID), any(UpdateAnalysisGroupMembershipDTO.class), + any(Logger.class))).thenReturn(studyDto()); + + mvc.perform(patch("/studies/" + STUDY_ID + "/members/" + RUN_ID + "/group") + .contentType("application/json").content("{\"groupId\":null}").principal(principal)) + .andExpect(status().isOk()); + + ArgumentCaptor body = + ArgumentCaptor.forClass(UpdateAnalysisGroupMembershipDTO.class); + verify(service).updateGroupMembership(eq(principal), eq(STUDY_ID), eq(RUN_ID), body.capture(), any(Logger.class)); + assertThat(body.getValue().groupId()).isNull(); + } + + @Test + void createGroupCarriesItsOptionalSeedRun() throws Exception { + when(service.createGroup(any(), eq(STUDY_ID), any(CreateAnalysisGroupDTO.class), any(Logger.class))) + .thenReturn(studyDto()); + + mvc.perform(post("/studies/" + STUDY_ID + "/groups").contentType("application/json") + .content("{\"name\":\"Drug arm A\",\"analysisId\":\"" + RUN_ID + "\"}").principal(principal)) + .andExpect(status().isCreated()); + + ArgumentCaptor body = ArgumentCaptor.forClass(CreateAnalysisGroupDTO.class); + verify(service).createGroup(eq(principal), eq(STUDY_ID), body.capture(), any(Logger.class)); + assertThat(body.getValue().name()).isEqualTo("Drug arm A"); + assertThat(body.getValue().analysisId()).isEqualTo(RUN_ID); + } + + @Test + void renamesAStudyAndAGroup() throws Exception { + when(service.renameStudy(any(), eq(STUDY_ID), any(RenameStudyDTO.class), any(Logger.class))) + .thenReturn(studyDto()); + when(service.renameGroup(any(), eq(STUDY_ID), eq(GROUP_ID), any(RenameAnalysisGroupDTO.class), any(Logger.class))) + .thenReturn(studyDto()); + + mvc.perform(patch("/studies/" + STUDY_ID).contentType("application/json") + .content("{\"name\":\"Renamed\"}").principal(principal)).andExpect(status().isOk()); + mvc.perform(patch("/studies/" + STUDY_ID + "/groups/" + GROUP_ID).contentType("application/json") + .content("{\"name\":\"Renamed group\"}").principal(principal)).andExpect(status().isOk()); + } + + // ------------------------------------------------------------------ deletes + + @Test + void deletingTheStudyLeavesNothingToReturn() throws Exception { + mvc.perform(delete("/studies/" + STUDY_ID).principal(principal)) + .andExpect(status().isNoContent()) + .andExpect(content().string("")); + } + + /** Losing a member or a group changes what is left, so those two answer with the remaining study. */ + @Test + void deletingAMemberOrAGroupAnswersWithTheUpdatedStudy() throws Exception { + when(service.removeAnalysis(any(), eq(STUDY_ID), eq(RUN_ID), any(Logger.class))).thenReturn(studyDto()); + when(service.deleteGroup(any(), eq(STUDY_ID), eq(GROUP_ID), any(Logger.class))).thenReturn(studyDto()); + + mvc.perform(delete("/studies/" + STUDY_ID + "/members/" + RUN_ID).principal(principal)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.id").value(STUDY_ID)) + .andExpect(jsonPath("$.groups[0].id").value(GROUP_ID)); + + mvc.perform(delete("/studies/" + STUDY_ID + "/groups/" + GROUP_ID).principal(principal)) + .andExpect(status().isOk()) + .andExpect(jsonPath("$.analysisIds[0]").value(RUN_ID)); + } + + // ------------------------------------------------------------------ failures + + @Test + void blankNameIsABadRequest() throws Exception { + when(service.createStudy(any(), any(CreateStudyDTO.class), any(Logger.class))) + .thenThrow(new BadRequestException("Study name must not be blank.")); + + mvc.perform(post("/studies").contentType("application/json").content("{\"name\":\" \"}").principal(principal)) + .andExpect(status().isBadRequest()) + .andExpect(jsonPath("$.statusCode").value(400)) + .andExpect(jsonPath("$.message").value("Study name must not be blank.")); + } + + @Test + void malformedIdIsABadRequest() throws Exception { + when(service.getStudy(any(), eq("not-a-uuid"), any(Logger.class))) + .thenThrow(new BadRequestException("Invalid studyId: not-a-uuid")); + + mvc.perform(get("/studies/not-a-uuid").principal(principal)) + .andExpect(status().isBadRequest()) + .andExpect(jsonPath("$.statusCode").value(400)); + } + + @Test + void duplicateNamesAreAConflict() throws Exception { + when(service.createStudy(any(), any(CreateStudyDTO.class), any(Logger.class))) + .thenThrow(new ConflictException("A study named 'My analysis group' already exists.")); + when(service.createGroup(any(), eq(STUDY_ID), any(CreateAnalysisGroupDTO.class), any(Logger.class))) + .thenThrow(new ConflictException("An analysis group named 'Drug arm A' already exists in this study.")); + + mvc.perform(post("/studies").contentType("application/json").content("{\"name\":\"My analysis group\"}").principal(principal)) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.statusCode").value(409)); + mvc.perform(post("/studies/" + STUDY_ID + "/groups").contentType("application/json") + .content("{\"name\":\"Drug arm A\"}").principal(principal)) + .andExpect(status().isConflict()) + .andExpect(jsonPath("$.statusCode").value(409)); + } + + @Test + void foreignStudiesAndForeignGroupsAreBothNotFound() throws Exception { + when(service.getStudy(any(), eq(STUDY_ID), any(Logger.class))) + .thenThrow(new StudyNotFoundException("Study with id : " + STUDY_ID + + " was not found for the active user.")); + when(service.renameGroup(any(), eq(STUDY_ID), eq(GROUP_ID), any(RenameAnalysisGroupDTO.class), any(Logger.class))) + .thenThrow(new AnalysisGroupNotFoundException("Analysis group with id : " + GROUP_ID + + " was not found in study : " + STUDY_ID)); + + mvc.perform(get("/studies/" + STUDY_ID).principal(principal)) + .andExpect(status().isNotFound()) + .andExpect(jsonPath("$.statusCode").value(404)); + mvc.perform(patch("/studies/" + STUDY_ID + "/groups/" + GROUP_ID).contentType("application/json") + .content("{\"name\":\"whatever\"}").principal(principal)) + .andExpect(status().isNotFound()) + .andExpect(jsonPath("$.statusCode").value(404)); + } + + /** A run the caller may not read must not become a study membership, and must not say 404 either. */ + @Test + void unreadableRunIsForbidden() throws Exception { + when(service.addAnalysis(any(), eq(STUDY_ID), any(AddStudyMemberDTO.class), any(Logger.class))) + .thenThrow(new UnauthorizedException("You don't have access to that analysis.")); + + mvc.perform(post("/studies/" + STUDY_ID + "/members").contentType("application/json") + .content("{\"analysisId\":\"" + RUN_ID + "\"}").principal(principal)) + .andExpect(status().isForbidden()) + .andExpect(jsonPath("$.statusCode").value(403)); + } + + private StudyDTO studyDto() { + return new StudyDTO(STUDY_ID, "My analysis group", List.of(RUN_ID), + List.of(new AnalysisGroupDTO(GROUP_ID, "Drug arm A", List.of(RUN_ID)))); + } +} diff --git a/src/test/java/hbp/mip/study/StudyDTOTest.java b/src/test/java/hbp/mip/study/StudyDTOTest.java new file mode 100644 index 000000000..f54a44ac7 --- /dev/null +++ b/src/test/java/hbp/mip/study/StudyDTOTest.java @@ -0,0 +1,85 @@ +package hbp.mip.study; + +import hbp.mip.analysis.AnalysisDAO; +import hbp.mip.user.UserDAO; +import org.junit.jupiter.api.Test; + +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * The mapping is the contract: three orderings have to survive the trip from the position columns to + * the arrays the dashboard renders, and an empty study has to answer with empty arrays rather than + * nulls (null fields are dropped from the JSON, which would break `study.groups.map(...)`). + */ +class StudyDTOTest { + + @Test + void mapsMembersGroupsAndGroupMembersToTheirStoredOrder() { + StudyDAO study = new StudyDAO( + new UserDAO("user", "User", "user@example.org", "subject"), "My analysis group", 1); + + AnalysisGroupDAO first = new AnalysisGroupDAO(study, "First", 1); + AnalysisGroupDAO second = new AnalysisGroupDAO(study, "Second", 2); + study.getGroups().add(second); + study.getGroups().add(first); + + UUID inFirstLow = uuid(); + UUID inFirstHigh = uuid(); + UUID ungrouped = uuid(); + UUID lateUngrouped = uuid(); + + // Added out of order on purpose: the response must follow the position columns, not insertion. + study.getMembers().add(member(study, inFirstHigh, first, 3, 2)); + study.getMembers().add(member(study, ungrouped, null, 1, null)); + study.getMembers().add(member(study, inFirstLow, second, 2, 1)); + study.getMembers().add(member(study, lateUngrouped, null, null, null)); + study.getMembers().get(2).setAnalysisGroup(first); + + var dto = StudyDTO.from(study); + + assertThat(dto.id()).isEqualTo(study.getId().toString()); + assertThat(dto.name()).isEqualTo("My analysis group"); + assertThat(dto.analysisIds()).containsExactly(ungrouped.toString(), inFirstLow.toString(), + inFirstHigh.toString(), lateUngrouped.toString()); + + assertThat(dto.groups()).extracting(AnalysisGroupDTO::name).containsExactly("First", "Second"); + assertThat(dto.groups().get(0).id()).isEqualTo(first.getId().toString()); + assertThat(dto.groups().get(0).analysisIds()) + .containsExactly(inFirstLow.toString(), inFirstHigh.toString()); + assertThat(dto.groups().get(1).analysisIds()).isEmpty(); + } + + @Test + void mapsAFreshStudyToEmptyArrays() { + StudyDAO study = new StudyDAO( + new UserDAO("user", "User", "user@example.org", "subject"), "Empty", 1); + + var dto = StudyDTO.from(study); + var collection = StudiesDTO.from(List.of(study)); + + assertThat(dto.analysisIds()).isEmpty(); + assertThat(dto.groups()).isEmpty(); + assertThat(collection.studies()).singleElement().satisfies(studyDto -> { + assertThat(studyDto.analysisIds()).isEmpty(); + assertThat(studyDto.groups()).isEmpty(); + }); + } + + private StudyMemberDAO member(StudyDAO study, UUID analysisId, AnalysisGroupDAO group, + Integer studyPosition, Integer groupPosition) { + AnalysisDAO analysis = new AnalysisDAO(); + analysis.setUuid(analysisId); + + StudyMemberDAO member = new StudyMemberDAO(study, analysis, studyPosition); + member.setAnalysisGroup(group); + member.setGroupPosition(groupPosition); + return member; + } + + private UUID uuid() { + return UUID.randomUUID(); + } +} diff --git a/src/test/java/hbp/mip/study/StudyServiceTest.java b/src/test/java/hbp/mip/study/StudyServiceTest.java new file mode 100644 index 000000000..6440b5120 --- /dev/null +++ b/src/test/java/hbp/mip/study/StudyServiceTest.java @@ -0,0 +1,660 @@ +package hbp.mip.study; + +import hbp.mip.analysis.AnalysisDAO; +import hbp.mip.analysis.AnalysisService; +import hbp.mip.user.ActiveUserService; +import hbp.mip.user.UserDAO; +import hbp.mip.user.UserDTO; +import hbp.mip.utils.Exceptions.BadRequestException; +import hbp.mip.utils.Exceptions.ConflictException; +import hbp.mip.utils.Exceptions.StudyNotFoundException; +import hbp.mip.utils.Exceptions.AnalysisGroupNotFoundException; +import hbp.mip.utils.Exceptions.UnauthorizedException; +import hbp.mip.utils.Logger; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.ArgumentCaptor; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; +import org.springframework.dao.DataIntegrityViolationException; +import org.springframework.security.core.Authentication; + +import java.sql.SQLException; +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.eq; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +class StudyServiceTest { + + private static final String USERNAME = "user"; + + @Mock + private ActiveUserService activeUserService; + + @Mock + private StudyRepository studyRepository; + + @Mock + private AnalysisService analysisService; + + @Mock + private Authentication authentication; + + private StudyService service; + + private final UserDTO user = new UserDTO(USERNAME, "User", "user@example.org", "subject", true); + private final Logger logger = new Logger(USERNAME, "test"); + + @BeforeEach + void setUp() { + service = new StudyService(activeUserService, studyRepository, analysisService); + + lenient().when(activeUserService.getActiveUser(authentication)).thenReturn(user); + lenient().when(studyRepository.saveAndFlush(any(StudyDAO.class))) + .thenAnswer(invocation -> invocation.getArgument(0)); + } + + // ------------------------------------------------------------------ studies + + @Test + void createStudy_collapsesWhitespaceAndPlacesItLast() { + givenOwnedStudies(study("Existing", 7)); + + var created = service.createStudy(authentication, new CreateStudyDTO(" My Analysis Group ", null), + logger); + + ArgumentCaptor saved = ArgumentCaptor.forClass(StudyDAO.class); + verify(studyRepository).saveAndFlush(saved.capture()); + assertThat(created.name()).isEqualTo("My Analysis Group"); + assertThat(saved.getValue().getSortOrder()).isEqualTo(8); + assertThat(created.analysisIds()).isEmpty(); + assertThat(created.groups()).isEmpty(); + } + + @Test + void createStudy_capsTheNameAtTheLengthTheFrontendAllows() { + givenOwnedStudies(); + + var created = service.createStudy(authentication, + new CreateStudyDTO(" " + "a".repeat(80) + " ", null), logger); + + assertThat(created.name()).hasSize(StudyService.MAX_NAME_LENGTH); + } + + @Test + void createStudy_rejectsANameThatIsOnlyWhitespace() { + assertThatThrownBy(() -> service.createStudy(authentication, new CreateStudyDTO(" \t\n ", null), logger)) + .isInstanceOf(BadRequestException.class); + + verify(studyRepository, never()).saveAndFlush(any(StudyDAO.class)); + } + + @Test + void createStudy_rejectsANameAlreadyTakenIgnoringCase() { + givenOwnedStudies(study("My Analysis Group", 1)); + + assertThatThrownBy(() -> service.createStudy(authentication, + new CreateStudyDTO(" my analysis group ", null), logger)) + .isInstanceOf(ConflictException.class); + + verify(studyRepository, never()).saveAndFlush(any(StudyDAO.class)); + } + + @Test + void renameStudy_rejectsSomebodyElsesStudyAsNotFound() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", "somebody-else"); + + assertThatThrownBy(() -> service.renameStudy(authentication, studyId.toString(), + new RenameStudyDTO("Taken By Me"), logger)) + .isInstanceOf(StudyNotFoundException.class); + } + + @Test + void renameStudy_keepsItsOwnNameAsNoConflict() { + UUID studyId = UUID.randomUUID(); + StudyDAO owned = givenStudy(studyId, "My Group", USERNAME); + givenOwnedStudies(owned); + + var renamed = service.renameStudy(authentication, studyId.toString(), + new RenameStudyDTO(" my group "), logger); + + assertThat(renamed.name()).isEqualTo("my group"); + } + + @Test + void getStudy_readsOnlyTheStudiesOfTheActiveUser() { + // The repository query is already owner scoped; findById is the one that must not leak either. + UUID mine = UUID.randomUUID(); + givenStudy(mine, "Mine", USERNAME); + + assertThat(service.getStudy(authentication, mine.toString(), logger).name()).isEqualTo("Mine"); + } + + @Test + void getStudy_hidesAStudyOwnedByAnotherUserBehindNotFound() { + UUID foreign = UUID.randomUUID(); + givenStudy(foreign, "Theirs", "somebody-else"); + + assertThatThrownBy(() -> service.getStudy(authentication, foreign.toString(), logger)) + .isInstanceOf(StudyNotFoundException.class); + } + + @Test + void getStudy_rejectsAnIdThatIsNotAnId() { + assertThatThrownBy(() -> service.getStudy(authentication, "not-a-uuid", logger)) + .isInstanceOf(BadRequestException.class); + } + + // ------------------------------------------------------------------ members + + @Test + void addAnalysis_checksTheRunIsReadableAndAppendsItLast() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + AnalysisDAO analysis = analysis(); + givenReadableAnalysis(analysis); + + var updated = service.addAnalysis(authentication, studyId.toString(), + new AddStudyMemberDTO(analysis.getUuid().toString()), logger); + + verify(analysisService).assertAnalysisAccessible(eq(authentication), eq(analysis.getUuid().toString()), + any(Logger.class)); + assertThat(updated.analysisIds()).containsExactly(analysis.getUuid().toString()); + + ArgumentCaptor saved = ArgumentCaptor.forClass(StudyDAO.class); + verify(studyRepository).saveAndFlush(saved.capture()); + assertThat(saved.getValue().getMembers()).singleElement() + .satisfies(member -> assertThat(member.getStudyPosition()).isEqualTo(1)); + } + + @Test + void addAnalysis_isIdempotentForARunTheStudyAlreadyHolds() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisDAO analysis = analysis(); + givenReadableAnalysis(analysis); + study.getMembers().add(new StudyMemberDAO(study, analysis, 1)); + + var again = service.addAnalysis(authentication, studyId.toString(), + new AddStudyMemberDTO(analysis.getUuid().toString()), logger); + + assertThat(again.analysisIds()).containsExactly(analysis.getUuid().toString()); + assertThat(study.getMembers()).hasSize(1); + verify(studyRepository, never()).saveAndFlush(any(StudyDAO.class)); + } + + @Test + void addAnalysis_refusesARunTheUserMayNotRead() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + AnalysisDAO hidden = analysis(); + when(analysisService.assertAnalysisAccessible(eq(authentication), eq(hidden.getUuid().toString()), + any(Logger.class))) + .thenThrow(new UnauthorizedException("You don't have access to that analysis.")); + + assertThatThrownBy(() -> service.addAnalysis(authentication, studyId.toString(), + new AddStudyMemberDTO(hidden.getUuid().toString()), logger)) + .isInstanceOf(UnauthorizedException.class); + + verify(studyRepository, never()).saveAndFlush(any(StudyDAO.class)); + } + + @Test + void addAnalysis_requiresAnAnalysisId() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + + assertThatThrownBy(() -> service.addAnalysis(authentication, studyId.toString(), + new AddStudyMemberDTO(" "), logger)) + .isInstanceOf(BadRequestException.class); + } + + @Test + void removeAnalysis_dropsTheRunFromTheStudyAndItsGroups() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO group = new AnalysisGroupDAO(study, "Baseline", 1); + study.getGroups().add(group); + AnalysisDAO first = analysis(); + AnalysisDAO second = analysis(); + StudyMemberDAO firstMember = new StudyMemberDAO(study, first, 1); + firstMember.setAnalysisGroup(group); + firstMember.setGroupPosition(1); + study.getMembers().add(firstMember); + study.getMembers().add(new StudyMemberDAO(study, second, 2)); + + var after = service.removeAnalysis(authentication, studyId.toString(), first.getUuid().toString(), logger); + assertThat(after.analysisIds()).containsExactly(second.getUuid().toString()); + assertThat(after.groups()).singleElement().satisfies(candidate -> + assertThat(candidate.analysisIds()).isEmpty()); + } + + @Test + void removeAnalysis_isHarmlessWhenTheRunIsNotInStudy() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + + service.removeAnalysis(authentication, studyId.toString(), analysis().getUuid().toString(), logger); + + verify(studyRepository, never()).saveAndFlush(any(StudyDAO.class)); + } + + // ------------------------------------------------------------------ groups + + @Test + void createGroup_appendsTheGroupAndCanSeedItWithAMember() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + study.getGroups().add(new AnalysisGroupDAO(study, "Baseline", 4)); + AnalysisDAO analysis = analysis(); + givenReadableAnalysis(analysis); + + var updated = service.createGroup(authentication, studyId.toString(), + new CreateAnalysisGroupDTO(" Drug arm A ", analysis.getUuid().toString()), logger); + + assertThat(updated.groups()).extracting(AnalysisGroupDTO::name).containsExactly("Baseline", "Drug arm A"); + assertThat(updated.groups().get(1).analysisIds()).containsExactly(analysis.getUuid().toString()); + assertThat(study.getMembers()).singleElement().satisfies(member -> { + assertThat(member.getStudyPosition()).isEqualTo(1); + assertThat(member.getGroupPosition()).isEqualTo(1); + }); + } + + @Test + void createGroup_rejectsAGroupNameAlreadyTakenIgnoringCase() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + study.getGroups().add(new AnalysisGroupDAO(study, "Drug arm A", 1)); + + assertThatThrownBy(() -> service.createGroup(authentication, studyId.toString(), + new CreateAnalysisGroupDTO(" drug ARM a ", null), logger)) + .isInstanceOf(ConflictException.class); + } + + @Test + void createGroup_mayShareTheNameOfItsOwnStudy() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + + var updated = service.createGroup(authentication, studyId.toString(), + new CreateAnalysisGroupDTO("my group", null), logger); + + assertThat(updated.groups()).singleElement().satisfies(group -> assertThat(group.name()).isEqualTo("my group")); + } + + @Test + void updateGroupMembership_movesTheRunOutOfThePreviousSet() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO baseline = new AnalysisGroupDAO(study, "Baseline", 1); + AnalysisGroupDAO armA = new AnalysisGroupDAO(study, "Drug arm A", 2); + study.getGroups().add(baseline); + study.getGroups().add(armA); + AnalysisDAO moved = analysis(); + StudyMemberDAO member = new StudyMemberDAO(study, moved, 1); + member.setAnalysisGroup(baseline); + member.setGroupPosition(3); + study.getMembers().add(member); + + var updated = service.updateGroupMembership(authentication, studyId.toString(), moved.getUuid().toString(), + new UpdateAnalysisGroupMembershipDTO(armA.getId().toString()), logger); + + assertThat(updated.groups()).filteredOn(group -> group.name().equals("Baseline")) + .singleElement().satisfies(group -> assertThat(group.analysisIds()).isEmpty()); + assertThat(updated.groups()).filteredOn(group -> group.name().equals("Drug arm A")) + .singleElement().satisfies(group -> assertThat(group.analysisIds()) + .containsExactly(moved.getUuid().toString())); + assertThat(member.getAnalysisGroup()).isSameAs(armA); + assertThat(member.getGroupPosition()).isEqualTo(1); + } + + @Test + void updateGroupMembership_createsTheMembershipWhenTheRunIsNotInStudyYet() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO armA = new AnalysisGroupDAO(study, "Drug arm A", 1); + study.getGroups().add(armA); + AnalysisDAO analysis = analysis(); + givenReadableAnalysis(analysis); + + var updated = service.updateGroupMembership(authentication, studyId.toString(), analysis.getUuid().toString(), + new UpdateAnalysisGroupMembershipDTO(armA.getId().toString()), logger); + + verify(analysisService).assertAnalysisAccessible(eq(authentication), eq(analysis.getUuid().toString()), + any(Logger.class)); + assertThat(updated.analysisIds()).containsExactly(analysis.getUuid().toString()); + assertThat(updated.groups()).singleElement().satisfies(group -> + assertThat(group.analysisIds()).containsExactly(analysis.getUuid().toString())); + } + + @Test + void updateGroupMembership_withoutAGroupLeavesTheRunInTheStudyUngrouped() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO armA = new AnalysisGroupDAO(study, "Drug arm A", 1); + study.getGroups().add(armA); + AnalysisDAO analysis = analysis(); + StudyMemberDAO member = new StudyMemberDAO(study, analysis, 1); + member.setAnalysisGroup(armA); + member.setGroupPosition(1); + study.getMembers().add(member); + + var updated = service.updateGroupMembership(authentication, studyId.toString(), analysis.getUuid().toString(), + new UpdateAnalysisGroupMembershipDTO(null), logger); + + assertThat(updated.analysisIds()).containsExactly(analysis.getUuid().toString()); + assertThat(updated.groups()).singleElement().satisfies(group -> assertThat(group.analysisIds()).isEmpty()); + assertThat(member.getAnalysisGroup()).isNull(); + assertThat(member.getGroupPosition()).isNull(); + } + + @Test + void updateGroupMembership_rejectsAGroupOfAnotherStudy() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + + assertThatThrownBy(() -> service.updateGroupMembership(authentication, studyId.toString(), + analysis().getUuid().toString(), new UpdateAnalysisGroupMembershipDTO(UUID.randomUUID().toString()), + logger)) + .isInstanceOf(AnalysisGroupNotFoundException.class); + } + + @Test + void renameGroup_renamesOnlyItsOwnSet() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO armA = new AnalysisGroupDAO(study, "Drug arm A", 1); + study.getGroups().add(armA); + + var updated = service.renameGroup(authentication, studyId.toString(), armA.getId().toString(), + new RenameAnalysisGroupDTO(" Drug arm B "), logger); + + assertThat(updated.groups()).singleElement().satisfies(group -> assertThat(group.name()).isEqualTo("Drug arm B")); + } + + @Test + void renameGroup_rejectsANameAnotherGroupAlreadyHas() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + study.getGroups().add(new AnalysisGroupDAO(study, "Drug arm A", 1)); + AnalysisGroupDAO armB = new AnalysisGroupDAO(study, "Drug arm B", 2); + study.getGroups().add(armB); + + assertThatThrownBy(() -> service.renameGroup(authentication, studyId.toString(), armB.getId().toString(), + new RenameAnalysisGroupDTO("drug arm a"), logger)) + .isInstanceOf(ConflictException.class); + } + + @Test + void deleteGroup_leavesItsRunsInTheStudyUngrouped() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO armA = new AnalysisGroupDAO(study, "Drug arm A", 1); + study.getGroups().add(armA); + AnalysisDAO first = analysis(); + AnalysisDAO second = analysis(); + for (AnalysisDAO run : List.of(first, second)) { + StudyMemberDAO member = new StudyMemberDAO(study, run, 1); + member.setAnalysisGroup(armA); + member.setGroupPosition(1); + study.getMembers().add(member); + } + + var after = service.deleteGroup(authentication, studyId.toString(), armA.getId().toString(), logger); + assertThat(after.groups()).isEmpty(); + assertThat(after.analysisIds()).containsExactly(first.getUuid().toString(), second.getUuid().toString()); + assertThat(study.getMembers()).allSatisfy(member -> { + assertThat(member.getAnalysisGroup()).isNull(); + assertThat(member.getGroupPosition()).isNull(); + }); + } + + @Test + void deleteStudy_removesTheStudyWithoutTouchingTheRuns() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + study.getMembers().add(new StudyMemberDAO(study, analysis(), 1)); + + service.deleteStudy(authentication, studyId.toString(), logger); + + ArgumentCaptor deleted = ArgumentCaptor.forClass(StudyDAO.class); + + verify(studyRepository).delete(deleted.capture()); + assertThat(deleted.getValue().getId()).isEqualTo(studyId); + } + + // ------------------------------------------------------------------ ordering + + @Test + void positionsKeepGrowingFromWhateverTheStudyAlreadyHolds() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO armA = new AnalysisGroupDAO(study, "Drug arm A", 5); + study.getGroups().add(armA); + AnalysisDAO first = analysis(); + AnalysisDAO second = analysis(); + AnalysisDAO third = analysis(); + givenReadableAnalysis(first, second, third); + StudyMemberDAO firstMember = new StudyMemberDAO(study, first, 4); + firstMember.setAnalysisGroup(armA); + firstMember.setGroupPosition(2); + study.getMembers().add(firstMember); + + service.addAnalysis(authentication, studyId.toString(), + new AddStudyMemberDTO(second.getUuid().toString()), logger); + service.updateGroupMembership(authentication, studyId.toString(), third.getUuid().toString(), + new UpdateAnalysisGroupMembershipDTO(armA.getId().toString()), logger); + + assertThat(study.getMembers()).extracting(StudyMemberDAO::getStudyPosition) + .containsExactly(4, 5, 6); + assertThat(study.getMembers()).filteredOn(member -> first.getUuid().equals(member.getAnalysis().getUuid())) + .singleElement().satisfies(member -> assertThat(member.getGroupPosition()).isEqualTo(2)); + assertThat(StudyDTO.from(study).analysisIds()) + .containsExactly(first.getUuid().toString(), second.getUuid().toString(), + third.getUuid().toString()); + } + + @Test + void getStudies_returnsEveryStudyOfTheActiveUserInOrder() { + StudyDAO first = study("First", 1); + StudyDAO second = study("Second", 2); + givenOwnedStudies(first, second); + + var studies = service.getStudies(authentication, logger); + + assertThat(studies.studies()).extracting(StudyDTO::name).containsExactly("First", "Second"); + } + + @Test + void getStudies_answersAnEmptyListInsteadOfANotFound() { + givenOwnedStudies(); + + assertThat(service.getStudies(authentication, logger).studies()).isEmpty(); + } + + // ------------------------------------------------------------------ create study with its first run + + @Test + void createStudy_canSeedItWithTheRunTheGestureStartedFrom() { + givenOwnedStudies(); + AnalysisDAO analysis = analysis(); + givenReadableAnalysis(analysis); + + var created = service.createStudy(authentication, + new CreateStudyDTO("New study", analysis.getUuid().toString()), logger); + + verify(analysisService).assertAnalysisAccessible(eq(authentication), eq(analysis.getUuid().toString()), + any(Logger.class)); + assertThat(created.analysisIds()).containsExactly(analysis.getUuid().toString()); + + ArgumentCaptor saved = ArgumentCaptor.forClass(StudyDAO.class); + verify(studyRepository).saveAndFlush(saved.capture()); + assertThat(saved.getValue().getMembers()).singleElement().satisfies(member -> { + assertThat(member.getStudyPosition()).isEqualTo(1); + assertThat(member.getAnalysisGroup()).isNull(); + }); + } + + @Test + void createStudy_writesNothingWhenTheSeedRunIsNotReadable() { + givenOwnedStudies(); + AnalysisDAO hidden = analysis(); + when(analysisService.assertAnalysisAccessible(eq(authentication), eq(hidden.getUuid().toString()), + any(Logger.class))).thenThrow(new UnauthorizedException("You don't have access to that analysis.")); + + assertThatThrownBy(() -> service.createStudy(authentication, + new CreateStudyDTO("New study", hidden.getUuid().toString()), logger)) + .isInstanceOf(UnauthorizedException.class); + + verify(studyRepository, never()).saveAndFlush(any(StudyDAO.class)); + } + + // ------------------------------------------------------------------ lost uniqueness races + + @Test + void aLostNameRaceInDatabaseAnswersConflictNotInternalError() { + givenOwnedStudies(); + when(studyRepository.saveAndFlush(any(StudyDAO.class))) + .thenThrow(new DataIntegrityViolationException("could not execute statement", + new SQLException("duplicate key value violates unique constraint", "23505"))); + + assertThatThrownBy(() -> service.createStudy(authentication, + new CreateStudyDTO("Nobody saw the other tab", null), logger)) + .isInstanceOf(ConflictException.class); + } + + @Test + void aLostGroupNameRaceInDatabaseAnswersConflictNotInternalError() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + when(studyRepository.saveAndFlush(any(StudyDAO.class))) + .thenThrow(new DataIntegrityViolationException("Batch entry rejected", + new SQLException("duplicate key", "23505"))); + + assertThatThrownBy(() -> service.createGroup(authentication, studyId.toString(), + new CreateAnalysisGroupDTO("Arm A", null), logger)) + .isInstanceOf(ConflictException.class); + } + + @Test + void anIntegrityFailureThatIsNotUniquenessIsNotRelabelledAsConflict() { + givenOwnedStudies(); + when(studyRepository.saveAndFlush(any(StudyDAO.class))) + .thenThrow(new DataIntegrityViolationException("could not execute statement", + new SQLException("null value in column \"name\" violates not-null constraint", "23502"))); + + assertThatThrownBy(() -> service.createStudy(authentication, + new CreateStudyDTO("Broken", null), logger)) + .isInstanceOf(DataIntegrityViolationException.class); + } + + // ------------------------------------------------------------------ per-study write locking + + @Test + void memberAndGroupWritesTakeTheStudyRowLock() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisGroupDAO group = new AnalysisGroupDAO(study, "Arm A", 1); + study.getGroups().add(group); + AnalysisDAO first = analysis(); + AnalysisDAO second = analysis(); + givenReadableAnalysis(first, second); + + service.addAnalysis(authentication, studyId.toString(), + new AddStudyMemberDTO(first.getUuid().toString()), logger); + service.updateGroupMembership(authentication, studyId.toString(), first.getUuid().toString(), + new UpdateAnalysisGroupMembershipDTO(group.getId().toString()), logger); + service.updateGroupMembership(authentication, studyId.toString(), first.getUuid().toString(), + new UpdateAnalysisGroupMembershipDTO(null), logger); + service.createGroup(authentication, studyId.toString(), + new CreateAnalysisGroupDTO("Arm B", second.getUuid().toString()), logger); + service.removeAnalysis(authentication, studyId.toString(), second.getUuid().toString(), logger); + service.deleteGroup(authentication, studyId.toString(), group.getId().toString(), logger); + + verify(studyRepository, times(6)).findByIdForUpdate(studyId); + verify(studyRepository, never()).findById(studyId); + } + + @Test + void readsDoNotTakeTheWriteLock() { + UUID studyId = UUID.randomUUID(); + givenStudy(studyId, "My Group", USERNAME); + + service.getStudy(authentication, studyId.toString(), logger); + + verify(studyRepository).findById(studyId); + verify(studyRepository, never()).findByIdForUpdate(studyId); + } + + /** + * The lock is what makes the pre-check see a competing writer: membership added before this call + * (whatever committed first) is honoured and the study is returned unchanged. + */ + @Test + void addAnalysis_underTheLockSeesAMembershipThatAlreadyCommitted() { + UUID studyId = UUID.randomUUID(); + StudyDAO study = givenStudy(studyId, "My Group", USERNAME); + AnalysisDAO analysis = analysis(); + givenReadableAnalysis(analysis); + study.getMembers().add(new StudyMemberDAO(study, analysis, 1)); + + var updated = service.addAnalysis(authentication, studyId.toString(), + new AddStudyMemberDTO(analysis.getUuid().toString()), logger); + + verify(studyRepository).findByIdForUpdate(studyId); + assertThat(updated.analysisIds()).containsExactly(analysis.getUuid().toString()); + verify(studyRepository, never()).saveAndFlush(any(StudyDAO.class)); + } + + // ------------------------------------------------------------------ helpers + + private void givenOwnedStudies(StudyDAO... studies) { + when(studyRepository.findOwnedStudies(USERNAME)).thenReturn(List.of(studies)); + } + + private StudyDAO givenStudy(UUID studyId, String name, String ownerUsername) { + StudyDAO study = new StudyDAO( + new UserDAO(ownerUsername, "User", "user@example.org", "subject"), name, 1); + study.setId(studyId); + // Reads resolve through findById, member/group writes through the locked findByIdForUpdate; a test + // exercises one of them, so both stubs are lenient. + lenient().when(studyRepository.findById(studyId)).thenReturn(Optional.of(study)); + lenient().when(studyRepository.findByIdForUpdate(studyId)).thenReturn(Optional.of(study)); + return study; + } + + private void givenReadableAnalysis(AnalysisDAO... analyses) { + for (AnalysisDAO analysis : analyses) { + lenient().when(analysisService.assertAnalysisAccessible(eq(authentication), + eq(analysis.getUuid().toString()), any(Logger.class))).thenReturn(analysis); + } + } + + private StudyDAO study(String name, int sortOrder) { + return new StudyDAO(userOwner(), name, sortOrder); + } + + private UserDAO userOwner() { + return new UserDAO(USERNAME, "User", "user@example.org", "subject"); + } + + private AnalysisDAO analysis() { + AnalysisDAO analysis = new AnalysisDAO(); + analysis.setUuid(UUID.randomUUID()); + analysis.setName("run"); + return analysis; + } +} diff --git a/src/test/java/hbp/mip/utils/ClaimUtilsDatasetVariablesTest.java b/src/test/java/hbp/mip/utils/ClaimUtilsDatasetVariablesTest.java index 435a11e80..950760ae3 100644 --- a/src/test/java/hbp/mip/utils/ClaimUtilsDatasetVariablesTest.java +++ b/src/test/java/hbp/mip/utils/ClaimUtilsDatasetVariablesTest.java @@ -22,7 +22,7 @@ class ClaimUtilsDatasetVariablesTest { void setUp() { claimUtils = new ClaimUtils(); ReflectionTestUtils.setField(claimUtils, "allDatasetsAllowedClaim", "role_research_dataset_all"); - ReflectionTestUtils.setField(claimUtils, "allExperimentsAllowedClaim", "role_research_experiment_all"); + ReflectionTestUtils.setField(claimUtils, "allAnalysesAllowedClaim", "role_research_experiment_all"); ReflectionTestUtils.setField(claimUtils, "datasetClaimPrefix", "role_research_dataset_"); }