Merge remote-tracking branch 'IQSS/develop' into

qqmyers · qqmyers · commit baa9dca10d6e · 2025-11-25T10:03:46.000-05:00
GDCC/8914-COAR-compliant_messaging
diff --git a/doc/release-notes/10490-COAR-Notify.md b/doc/release-notes/10490-COAR-Notify.md
@@ -1,18 +1,18 @@
 ### Support for COAR Notify Relationship Announcement
 
-Dataverse now supports sending and recieving [Linked Data Notification ](https://www.w3.org/TR/ldn/) messages involved in the 
+Dataverse now supports sending and receiving [Linked Data Notification ](https://www.w3.org/TR/ldn/) messages involved in the 
 [COAR Notify Relationship Announcement Workflow](https://coar-notify.net/catalogue/workflows/repository-relationship-repository/).
 
 Dataverse can send messages to configured repositories announcing that a dataset has a related publication (as defined in the dataset metadata). This may be done automatically upon publication or triggered manually by a superuser. The receiving repository may do anything with the message, with the default expectation being that the repository will create a backlink from the publication to the dataset (assuming the publication exists in the repository, admins agree the link makes sense, etc.)
 
-Conversely, Dataverse can recieve notices from other configured repositories announcing relationships between their publications and datasets. If the referenced dataset exists in the Dataverse instance, a notification will be sent to users who can publish the dataset, or, optionally only superusers who can publish the dataset. They can then decide whether to create a backlink to the publication in the dataset metadata.
+Conversely, Dataverse can receive notices from other configured repositories announcing relationships between their publications and datasets. If the referenced dataset exists in the Dataverse instance, a notification will be sent to users who can publish the dataset, or, optionally, only superusers who can publish the dataset. They can then decide whether to create a backlink to the publication in the dataset metadata.
 
 (Earlier releases of Dataverse had experimental support in this area that was based on message formats defined prior to finalization of the COAR Notify specification for relationship announcements.)
 
 #### New Settings/JVM Options
 
 Configuration for sending messages involves specifying the
-:COARNotifyRelationshipAnnpuncementTargets and :COARNotifyRelationshipAnnpuncementTriggerFields
+:COARNotifyRelationshipAnnouncementTargets and :COARNotifyRelationshipAnnouncementTriggerFields
 
 Configuration to receive messages involves specifying
 DATAVERSE_LDN_ALLOWED_HOSTS (dataverse.ldn.allowed-hosts)
diff --git a/doc/sphinx-guides/source/api/linkeddatanotification.rst b/doc/sphinx-guides/source/api/linkeddatanotification.rst
@@ -11,7 +11,7 @@ Upon receipt of a relevant message, Dataverse will create Announcement Received
 
 The ``dataverse.ldn.allowed-hosts`` JVM option is a comma-separated list of hosts from which Dataverse will accept and process messages. By default, no hosts are allowed. ``*`` can be used in testing to indicate all hosts are allowed.
 
-The ``dataverse.ldn.coar-noptify.relationship-announcement.notify-superusers-only`` JVM option can be set to ``true`` to restrict notifications to superusers only (those who can publish the dataset). The default is to notify all users who can publish the dataset.
+The ``dataverse.ldn.coar-notify.relationship-announcement.notify-superusers-only`` JVM option can be set to ``true`` to restrict notifications to superusers only (those who can publish the dataset). The default is to notify all users who can publish the dataset.
 
 Messages can be sent via POST, using the application/ld+json ContentType:
 
diff --git a/doc/sphinx-guides/source/api/native-api.rst b/doc/sphinx-guides/source/api/native-api.rst
@@ -8241,7 +8241,7 @@ Get details of a workflow with a given id::
 
    GET http://$SERVER/api/admin/workflows/$id
 
-Add a new workflow. Request body specifies the workflow properties and steps in JSON format.
+Add a new workflow. Request body specifies the workflow properties and steps in JSON format. Specifically, the body of the message should be a JSON Object with a String "name" for the workflow and a "steps" JSON Array containing a JSON Object per workflow step. (See :doc:`/developers/workflows` for the exiting steps and their required JSON representations.)
 Sample ``json`` files are available at ``scripts/api/data/workflows/``::
 
    POST http://$SERVER/api/admin/workflows
diff --git a/doc/sphinx-guides/source/installation/config.rst b/doc/sphinx-guides/source/installation/config.rst
@@ -3803,14 +3803,14 @@ Can also be set via any `supported MicroProfile Config API source`_, e.g. the en
 Linked Data Notifications (LDN) Allowed Hosts
 +++++++++++++++++++++++++++++++++++++++++++++
 
-Dataverse supports receiving LDN notifications via the /api/inbox endpoint. The datavers.ldn.allowed-hosts allows you to specify the list of host IP addresses from which LDN notifications can be received, or ``*`` to receive messages from anywhere.
+Dataverse supports receiving LDN notifications via the /api/inbox endpoint. The dataverse.ldn.allowed-hosts allows you to specify the list of host IP addresses from which LDN notifications can be received, or ``*`` to receive messages from anywhere.
 
 Example: ``dataverse.ldn.allowed-hosts=*``
 
 COAR Notify Relationship Announcement Notify Superusers Only
 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 
-When Dataverse receives an LDN message conforming to the COAR Notify Relationship Announcement format and the message is about a Dataset hosted in the installation, Dataverse will send an notification to users who have permission to publish the dataset.
+When Dataverse receives an LDN message conforming to the COAR Notify Relationship Announcement format and the message is about a dataset hosted in the installation, Dataverse will send an notification to users who have permission to publish the dataset.
 This can instead be restricted to only superusers who can publish the dataset using this option.
 
 Example: ``dataverse.coar-notify.relationship-announcement.notify-superusers-only=true``
diff --git a/src/main/java/edu/harvard/iq/dataverse/api/ldn/COARNotifyRelationshipAnnouncement.java b/src/main/java/edu/harvard/iq/dataverse/api/ldn/COARNotifyRelationshipAnnouncement.java
@@ -96,6 +96,7 @@ public void processMessage(JsonObject msgObject) {
         Dataset dataset = datasetService.findByGlobalId(objectId);
         if (dataset == null) {
             logger.fine("Didn't find dataset for object ID: " + objectId + " - ignoring");
+            return;
         }
 
         // Create the citing resource JSON
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/LDNInboxIT.java b/src/test/java/edu/harvard/iq/dataverse/api/LDNInboxIT.java
@@ -1,251 +1,24 @@
-
 package edu.harvard.iq.dataverse.api;
 
-import jakarta.json.Json;
-import jakarta.json.JsonObject;
-import jakarta.json.JsonObjectBuilder;
-import org.junit.jupiter.api.AfterAll;
-import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
-import org.mockito.Mockito;
-
-import edu.harvard.iq.dataverse.DataverseServiceBean;
-import edu.harvard.iq.dataverse.branding.BrandingUtil;
-import edu.harvard.iq.dataverse.settings.JvmSettings;
-import edu.harvard.iq.dataverse.settings.SettingsServiceBean;
-import edu.harvard.iq.dataverse.util.testing.JvmSetting;
-import edu.harvard.iq.dataverse.util.testing.LocalJvmSettings;
-import edu.harvard.iq.dataverse.workflow.internalspi.COARNotifyRelationshipAnnouncementStep;
 import static edu.harvard.iq.dataverse.workflow.internalspi.COARNotifyRelationshipAnnouncementStep.DATACITE_URI_PREFIX;
-import io.restassured.RestAssured;
 import io.restassured.response.Response;
 
-import java.util.UUID;
-
-import static jakarta.ws.rs.core.Response.Status.BAD_REQUEST;
 import static jakarta.ws.rs.core.Response.Status.FORBIDDEN;
-import static jakarta.ws.rs.core.Response.Status.OK;
-import static jakarta.ws.rs.core.Response.Status.SERVICE_UNAVAILABLE;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.CoreMatchers.notNullValue;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
-@LocalJvmSettings
-@JvmSetting(key = JvmSettings.LINKEDDATANOTIFICATION_ALLOWED_HOSTS, value = "*")
 public class LDNInboxIT {
 
-    private static String apiToken;
-    private static String username;
-    private static String dataverseAlias;
-    private static String datasetPid;
-    private static Integer datasetId;
-    private static String superuserApiToken;
-    private static String superusername;
-
-    private static final String FRBR_SUPPLEMENT = "http://purl.org/vocab/frbr/core#supplement";
-
-    static SettingsServiceBean settingsServiceBean = Mockito.mock(SettingsServiceBean.class);
-    static DataverseServiceBean dataverseServiceBean = Mockito.mock(DataverseServiceBean.class);
-
-    @BeforeAll
-    public static void setUpClass() {
-        RestAssured.baseURI = UtilIT.getRestAssuredBaseUri();
-
-        // Create test user and get API token
-        Response createUser = UtilIT.createRandomUser();
-        apiToken = UtilIT.getApiTokenFromResponse(createUser);
-        username = UtilIT.getUsernameFromResponse(createUser);
-
-        // Create superuser for receiving notifications
-        Response createSuperuser = UtilIT.createRandomUser();
-        superuserApiToken = UtilIT.getApiTokenFromResponse(createSuperuser);
-        superusername = UtilIT.getUsernameFromResponse(createSuperuser);
-        Response makeSuperuser = UtilIT.setSuperuserStatus(superusername, true);
-        makeSuperuser.then().assertThat().statusCode(OK.getStatusCode());
-
-        // Create dataverse
-        Response createDataverse = UtilIT.createRandomDataverse(apiToken);
-        createDataverse.then().assertThat().statusCode(201);
-        dataverseAlias = UtilIT.getAliasFromResponse(createDataverse);
-
-        // Create and publish a dataset
-        Response createDataset = UtilIT.createRandomDatasetViaNativeApi(dataverseAlias, apiToken);
-        createDataset.then().assertThat().statusCode(201);
-        datasetId = UtilIT.getDatasetIdFromResponse(createDataset);
-        datasetPid = UtilIT.getDatasetPersistentIdFromResponse(createDataset);
-
-        // Publish the dataset
-        Response publishDataverse = UtilIT.publishDataverseViaNativeApi(dataverseAlias, apiToken);
-        publishDataverse.then().assertThat().statusCode(OK.getStatusCode());
-
-        Response publishDataset = UtilIT.publishDatasetViaNativeApi(datasetPid, "major", apiToken);
-        publishDataset.then().assertThat().statusCode(OK.getStatusCode());
-
-        // Setup mocks behavior, inject as deps - needed to build announcements
-        Mockito.when(settingsServiceBean.getValueForKey(SettingsServiceBean.Key.InstallationName))
-                .thenReturn("LDN IT Tester");
-        BrandingUtil.injectServices(dataverseServiceBean, settingsServiceBean);
-    }
-
-    @AfterAll
-    public static void afterClass() {
-        // Clean up: remove test dataset and dataverse
-        if (datasetId != null) {
-            Response destroyDataset = UtilIT.destroyDataset(datasetId, apiToken);
-            destroyDataset.then().assertThat().statusCode(OK.getStatusCode());
-        }
-
-        if (dataverseAlias != null) {
-            Response deleteDataverse = UtilIT.deleteDataverse(dataverseAlias, apiToken);
-            deleteDataverse.then().assertThat().statusCode(OK.getStatusCode());
-        }
-
-        // Delete test users
-        Response deleteUser = UtilIT.deleteUser(username);
-        deleteUser.then().assertThat().statusCode(OK.getStatusCode());
-        Response deleteSuperuser = UtilIT.deleteUser(superusername);
-        deleteSuperuser.then().assertThat().statusCode(OK.getStatusCode());
-    }
-
-    @Test
-    public void testAcceptRelationshipAnnouncementMessage() {
-        // Create a COAR Notify Relationship Announcement message
-        String citingResourceId = "https://doi.org/10.1234/example-publication";
-        String relationship = DATACITE_URI_PREFIX + "Cites";
-
-        String message = createRelationshipAnnouncementMessage(citingResourceId, datasetPid, relationship);
-
-        // Send the message to the LDN inbox
-        Response response = UtilIT.sendMessageToLDNInbox(message);
-
-        // Verify the response
-        response.then().assertThat().statusCode(OK.getStatusCode()).body("data.message", equalTo("Message Received"));
-
-        // Wait a moment for notification to be created
-        try {
-            Thread.sleep(1000);
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-        }
-
-        // Verify that a notification was created for the superuser
-        Response notifications = UtilIT.getNotifications(superuserApiToken);
-
-        notifications.then().assertThat().statusCode(OK.getStatusCode()).body("data", notNullValue());
-
-        // Check that at least one notification exists with type DATASETMENTIONED
-        String notificationsJson = notifications.asString();
-        assertTrue(notificationsJson.contains("DATASETMENTIONED"), "Expected to find DATASETMENTIONED notification");
-        assertTrue(notificationsJson.contains(citingResourceId), "Expected notification to contain citing resource ID");
-    }
+    private static String datasetPid ="doi:10.5072/F2ABCDEF";
 
+    //Simple test to assure that the default with no hosts allowed causes a message to get rejected.
     @Test
-    @JvmSetting(key = JvmSettings.LINKEDDATANOTIFICATION_ALLOWED_HOSTS, value = "192.0.2.1")
-    public void testRejectMessageFromNonWhitelistedHost() {
-        String message = createRelationshipAnnouncementMessage("https://doi.org/10.1234/test", datasetPid,
+    public void testRejectMessageFromNonAllowedHost() {
+        String message = LDNInboxTest.createRelationshipAnnouncementMessage("https://doi.org/10.1234/test", datasetPid,
                 DATACITE_URI_PREFIX + "Cites");
 
         // Send the message - should be rejected
         Response response = UtilIT.sendMessageToLDNInbox(message);
 
         response.then().assertThat().statusCode(FORBIDDEN.getStatusCode());
     }
-
-    @Test
-    public void testRejectInvalidJsonLD() {
-        String invalidJson = "{ this is not valid json }";
-
-        Response response = UtilIT.sendMessageToLDNInbox(invalidJson);
-
-        response.then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
-    }
-
-    @Test
-    public void testRejectMessageForNonExistentDataset() {
-        String nonExistentPid = "doi:10.5072/FK2/NONEXISTENT";
-
-        String message = createRelationshipAnnouncementMessage("https://doi.org/10.1234/test", nonExistentPid,
-                DATACITE_URI_PREFIX + "Cites");
-
-        Response response = UtilIT.sendMessageToLDNInbox(message);
-
-        response.then().assertThat().statusCode(SERVICE_UNAVAILABLE.getStatusCode());
-    }
-
-    @Test
-    public void testAcceptMessageWithMultipleRelationshipTypes() {
-        // Test different relationship types - the ones supported by Dataverse and the
-        // default from DSpace
-        String[] relationships = { DATACITE_URI_PREFIX + "Cites", DATACITE_URI_PREFIX + "IsSupplementTo",
-                DATACITE_URI_PREFIX + "IsReferencedBy", DATACITE_URI_PREFIX + "IsCitedBy",
-                DATACITE_URI_PREFIX + "IsSupplementedBy", DATACITE_URI_PREFIX + "References", FRBR_SUPPLEMENT };
-
-        for (String relationship : relationships) {
-            String message = createRelationshipAnnouncementMessage(
-                    "https://doi.org/10.1234/test-" + relationship.toLowerCase(), datasetPid, relationship);
-
-            Response response = UtilIT.sendMessageToLDNInbox(message);
-
-            response.then().assertThat().statusCode(OK.getStatusCode()).body("data.message",
-                    equalTo("Message Received"));
-        }
-    }
-
-    @Test
-    public void testAcceptMessageWithUrn() {
-        // Test with URN format identifier
-        String urnPid = "urn:nbn:de:0000-12345";
-
-        // Create a dataset with URN (in real scenario, this would be configured)
-        // For this test, we'll use the existing dataset but reference it with a URN in
-        // the message
-        String message = createRelationshipAnnouncementMessage("https://doi.org/10.1234/test-urn", urnPid,
-                DATACITE_URI_PREFIX + "Cites");
-
-        Response response = UtilIT.sendMessageToLDNInbox(message);
-
-        response.then().assertThat().statusCode(OK.getStatusCode());
-    }
-
-    @Test
-    public void testAcceptMessageWithHandle() {
-        // Test with Handle format identifier
-        String handlePid = "hdl:1234.5/67890";
-
-        String message = createRelationshipAnnouncementMessage("https://doi.org/10.1234/test-handle", handlePid,
-                DATACITE_URI_PREFIX + "Cites");
-
-        Response response = UtilIT.sendMessageToLDNInbox(message);
-
-        response.then().assertThat().statusCode(OK.getStatusCode());
-    }
-
-    @Test
-    public void testRejectMessageWithNonUriRelationship() {
-        // Test with an unsupported relationship type
-        String message = createRelationshipAnnouncementMessage("https://doi.org/10.1234/test-unsupported", datasetPid,
-                "UnsupportedRelationType");
-
-        Response response = UtilIT.sendMessageToLDNInbox(message);
-
-        // Should be rejected
-        response.then().assertThat().statusCode(BAD_REQUEST.getStatusCode());
-    }
-
-    /**
-     * Helper method to create a COAR Notify Relationship Announcement message with
-     * specific resource type
-     */
-    private String createRelationshipAnnouncementMessage(String citingResourceId, String targetDatasetPid,
-            String relationship) {
-
-        JsonObjectBuilder targetBuilder = Json.createObjectBuilder().add("id", RestAssured.baseURI)
-                .add("inbox", RestAssured.baseURI + "/api/inbox").add("type", "Service");
-
-        JsonObject rel = Json.createObjectBuilder().add("as:object", targetDatasetPid)
-                .add("as:relationship", relationship).add("as:subject", citingResourceId)
-                .add("id", "urn:uuid:" + UUID.randomUUID().toString()).add("type", "Relationship").build();
-
-        return COARNotifyRelationshipAnnouncementStep.buildAnnouncement(rel, targetBuilder.build());
-    }
 }
diff --git a/src/test/java/edu/harvard/iq/dataverse/api/LDNInboxTest.java b/src/test/java/edu/harvard/iq/dataverse/api/LDNInboxTest.java
diff --git a/tests/integration-tests.txt b/tests/integration-tests.txt

Original file line number	Diff line number	Diff line change
`@@ -96,6 +96,7 @@ public void processMessage(JsonObject msgObject) {`
`96`	`96`	`Dataset dataset = datasetService.findByGlobalId(objectId);`
`97`	`97`	`if (dataset == null) {`
`98`	`98`	`logger.fine("Didn't find dataset for object ID: " + objectId + " - ignoring");`
	`99`	`+ return;`
`99`	`100`	`}`
`100`	`101`
`101`	`102`	`// Create the citing resource JSON`