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_");
}