DSpace9.3/Fix CLARIN link rels returning 404: register link repositories under plural model names (#1404)

* Register CLARIN link repositories under plural model names (DSpace 9 contract)

Six CLARIN LinkRestRepository beans are still registered under the singular model
name, so all six advertised sub-resources return 404 on the v9 base while they
return 200 on 7.6.5.

DSpace 7 singularized the URL segment before the bean lookup --
Utils.getLinkResourceRepository() called makeSingular(modelPlural). DSpace 9
removed that step and looks the bean up under the plural segment verbatim, so a
link repository must now be registered as <category>.<typePlural>.<rel>. The
upstream migration renamed its own 71 link repositories accordingly and added
PLURAL_NAME to the REST models, but these six CLARIN ones were missed.

Note ClarinLicenseResourceUserAllowanceRestRepository (the MAIN repository) *was*
migrated to PLURAL_NAME, which is why GET /core/clarinlruallowances/242 returns
200 while every one of its rels 404s. Migrating a main repository without its
link repositories leaves all its sub-resources dead.

Why this is easy to misread: a missing bean raises RepositoryNotFoundException,
and a missing route resolves BEFORE any authorization check. The one defect
therefore surfaces as "404 != 200" for an admin, "404 != 401" for anonymous and
"404 != 403" for a non-owner -- it reads like an authorization problem, and the
404 body names the plural type that is not how the bean is registered:

  {"status":404,"message":"The repository type core.clarinlruallowances was not found"}

Meanwhile the allowance JSON keeps advertising all three _links, so the API
describes endpoints it cannot serve.

Measured, admin token, dev-6.pc:8603 (9.3) vs dev-5.pc:88 (7.6.5):

  core/clarinlruallowances/242                            200   200
  core/clarinlruallowances/242/userMetadata               *404*  200
  core/clarinlruallowances/242/userRegistration           *404*  200
  core/clarinlruallowances/242/resourceMapping            *404*  200
  core/clarinuserregistrations/1/userMetadata             *404*  200
  core/clarinuserregistrations/1/clarinLicenses           *404*  200
  core/clarinlicenseresourcemappings/1383/clarinLicense   *404*  200

Audit backing the "six and only six" claim: of 77 LinkRestRepository
implementations on this branch, 71 already use PLURAL_NAME, these 6 used NAME,
and none uses a literal bean-name string. Every main (non-link) repository is
already plural. So this closes the gap completely.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* Add regression test for the CLARIN link-repository bean naming contract

Nothing in the suite caught the previous commit's bug: no IT traverses any of the
six rels as a URL sub-path, so all six could 404 in production while CI stayed
green. It surfaced only in the external dspace-rest-test suite, as 8 failing
test_endpoints tests whose messages looked like an authorization problem.

The test asserts the invariant directly through
Utils.getLinkResourceRepository() -- the same lookup RestResourceController
performs when a client traverses a rel -- rather than over HTTP. Going over HTTP
could not isolate this defect: these link repositories also raise
ResourceNotFoundException, another 404, when the linked data simply does not
exist, so telling "route missing" from "no data" would need fixtures for a
bitstream, a licence, a resource mapping, a user registration and user metadata
per rel, and would still conflate the two on failure.

It is driven off the @LinksRest annotation instead of a hardcoded rel list, so a
rel added to any of these three models is covered automatically.

Covers all six rels: clarinlruallowances {resourceMapping, userRegistration,
userMetadata}, clarinuserregistrations {clarinLicenses, userMetadata},
clarinlicenseresourcemappings {clarinLicense}.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

* Report an actionable failure when a link repository bean is missing

Addresses Copilot review feedback on #1404.

utils.getLinkResourceRepository() throws RepositoryNotFoundException rather than
returning null, so the assertNotNull message was unreachable: the test would have
failed with a raw exception instead.

That mattered more than it looks, because RepositoryNotFoundException.getMessage()
formats only "<apiCategory>.<model>":

  "The repository type core.clarinlruallowances was not found"

It never names the rel, so on ClarinLicenseResourceUserAllowanceRest -- which has
three -- the failure could not say whether resourceMapping, userRegistration or
userMetadata was the unregistered one. The wording is also misleading in this
context: it claims the repository *type* is missing when the main repository
resolves fine and only the link repository bean is absent, which is exactly the
confusion this test exists to prevent.

The lookup failure is now caught and rethrown as an AssertionError naming the
expected bean and the required fix, with the original exception chained as the
cause so nothing is lost (Assert.fail would have discarded it).

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Matus Kasak <matus.kasak@dataquest.sk>
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: 3 people

dspace-server-webapp/src/main/java/org/dspace/app/rest/repository/CLRUAResourceMappingLinkRepository.java

@@ -28,7 +28,7 @@
 /**
  * CLRUA = ClarinLicenseResourceUserAllowance
  */
-@Component(ClarinLicenseResourceUserAllowanceRest.CATEGORY + "." + ClarinLicenseResourceUserAllowanceRest.NAME +
+@Component(ClarinLicenseResourceUserAllowanceRest.CATEGORY + "." + ClarinLicenseResourceUserAllowanceRest.PLURAL_NAME +
         "." + ClarinLicenseResourceUserAllowanceRest.RESOURCE_MAPPING)
 public class CLRUAResourceMappingLinkRepository extends AbstractDSpaceRestRepository
         implements LinkRestRepository {

dspace-server-webapp/src/main/java/org/dspace/app/rest/repository/CLRUAUUserRegistrationLinkRepository.java

@@ -29,7 +29,7 @@
 /**
  * CLRUA = ClarinLicenseResourceUserAllowance
  */
-@Component(ClarinLicenseResourceUserAllowanceRest.CATEGORY + "." + ClarinLicenseResourceUserAllowanceRest.NAME +
+@Component(ClarinLicenseResourceUserAllowanceRest.CATEGORY + "." + ClarinLicenseResourceUserAllowanceRest.PLURAL_NAME +
         "." + ClarinLicenseResourceUserAllowanceRest.USER_REGISTRATION)
 public class CLRUAUUserRegistrationLinkRepository extends AbstractDSpaceRestRepository
         implements LinkRestRepository {

dspace-server-webapp/src/main/java/org/dspace/app/rest/repository/CLRUAUserMetadataLinkRepository.java

@@ -32,7 +32,7 @@
 /**
  * CLRUA = ClarinLicenseResourceUserAllowance
  */
-@Component(ClarinLicenseResourceUserAllowanceRest.CATEGORY + "." + ClarinLicenseResourceUserAllowanceRest.NAME +
+@Component(ClarinLicenseResourceUserAllowanceRest.CATEGORY + "." + ClarinLicenseResourceUserAllowanceRest.PLURAL_NAME +
         "." + ClarinLicenseResourceUserAllowanceRest.USER_METADATA)
 public class CLRUAUserMetadataLinkRepository extends AbstractDSpaceRestRepository
         implements LinkRestRepository {

dspace-server-webapp/src/main/java/org/dspace/app/rest/repository/CUserRegistrationCLicenseLinkRepository.java

@@ -27,7 +27,7 @@
 import org.springframework.data.rest.webmvc.ResourceNotFoundException;
 import org.springframework.stereotype.Component;
 
-@Component(ClarinUserRegistrationRest.CATEGORY + "." + ClarinUserRegistrationRest.NAME + "." +
+@Component(ClarinUserRegistrationRest.CATEGORY + "." + ClarinUserRegistrationRest.PLURAL_NAME + "." +
         ClarinUserRegistrationRest.CLARIN_LICENSES)
 public class CUserRegistrationCLicenseLinkRepository extends AbstractDSpaceRestRepository
         implements LinkRestRepository {

dspace-server-webapp/src/main/java/org/dspace/app/rest/repository/ClarinResourceMappingCLicenseLinkRepository.java

@@ -24,7 +24,7 @@
 import org.springframework.data.rest.webmvc.ResourceNotFoundException;
 import org.springframework.stereotype.Component;
 
-@Component(ClarinLicenseResourceMappingRest.CATEGORY + "." + ClarinLicenseResourceMappingRest.NAME +
+@Component(ClarinLicenseResourceMappingRest.CATEGORY + "." + ClarinLicenseResourceMappingRest.PLURAL_NAME +
         "." + ClarinLicenseResourceMappingRest.CLARIN_LICENSE)
 public class ClarinResourceMappingCLicenseLinkRepository extends AbstractDSpaceRestRepository
         implements LinkRestRepository {

dspace-server-webapp/src/main/java/org/dspace/app/rest/repository/ClarinUserRegistrationUserMetadataLinkRepository.java

@@ -25,7 +25,7 @@
 import org.springframework.data.rest.webmvc.ResourceNotFoundException;
 import org.springframework.stereotype.Component;
 
-@Component(ClarinUserRegistrationRest.CATEGORY + "." + ClarinUserRegistrationRest.NAME + "." +
+@Component(ClarinUserRegistrationRest.CATEGORY + "." + ClarinUserRegistrationRest.PLURAL_NAME + "." +
         ClarinUserRegistrationRest.USER_METADATA)
 public class ClarinUserRegistrationUserMetadataLinkRepository extends AbstractDSpaceRestRepository
         implements LinkRestRepository {

dspace-server-webapp/src/test/java/org/dspace/app/rest/ClarinLinkRestRepositoryBeanNameIT.java

@@ -0,0 +1,103 @@
+/**
+ * The contents of this file are subject to the license and copyright
+ * detailed in the LICENSE and NOTICE files at the root of the source
+ * tree and available online at
+ *
+ * http://www.dspace.org/license/
+ */
+package org.dspace.app.rest;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.dspace.app.rest.exception.RepositoryNotFoundException;
+import org.dspace.app.rest.model.ClarinLicenseResourceMappingRest;
+import org.dspace.app.rest.model.ClarinLicenseResourceUserAllowanceRest;
+import org.dspace.app.rest.model.ClarinUserRegistrationRest;
+import org.dspace.app.rest.model.LinkRest;
+import org.dspace.app.rest.model.LinksRest;
+import org.dspace.app.rest.model.RestAddressableModel;
+import org.dspace.app.rest.repository.LinkRestRepository;
+import org.dspace.app.rest.test.AbstractControllerIntegrationTest;
+import org.dspace.app.rest.utils.Utils;
+import org.junit.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+/**
+ * Guards the DSpace 9 link-repository bean naming contract for the CLARIN models.
+ * <P>
+ * DSpace 7 resolved a rel by singularizing the URL segment before the bean lookup
+ * ({@code Utils.getLinkResourceRepository} called {@code makeSingular}). DSpace 9 removed that
+ * step and looks the bean up under the plural segment verbatim, so every
+ * {@link LinkRestRepository} must be registered as
+ * {@code <category>.<typePlural>.<rel>}. A repository still registered under the singular name
+ * is simply never found: the lookup raises {@code RepositoryNotFoundException}, the client gets
+ * a 404, and because a missing route resolves BEFORE any authorization check the same defect
+ * shows up as "404 instead of 200" for an admin and "404 instead of 401/403" for everyone else.
+ * It therefore reads like an authorization bug while the object's own {@code _links} keep
+ * advertising the dead rels.
+ * <P>
+ * This test asserts the invariant directly instead of going through HTTP, because the link
+ * repositories also raise {@code ResourceNotFoundException} (another 404) when the linked data
+ * simply does not exist -- an endpoint test could not tell the two apart without fixtures for
+ * every entity type. It is deliberately driven off the {@link LinksRest} annotation rather than
+ * a hardcoded list, so a rel added to any of these models is covered automatically.
+ */
+public class ClarinLinkRestRepositoryBeanNameIT extends AbstractControllerIntegrationTest {
+
+    @Autowired
+    private Utils utils;
+
+    /**
+     * Asserts that every rel declared via {@link LinksRest} on the given model resolves to a
+     * registered {@link LinkRestRepository}, using the same lookup {@link RestResourceController}
+     * performs when a client traverses the rel.
+     *
+     * @param modelClass the REST model whose declared rels should all be resolvable
+     */
+    private void assertAllDeclaredRelsResolve(Class<? extends RestAddressableModel> modelClass)
+            throws ReflectiveOperationException {
+        RestAddressableModel model = modelClass.getDeclaredConstructor().newInstance();
+        LinksRest linksRest = modelClass.getDeclaredAnnotation(LinksRest.class);
+        assertNotNull(modelClass.getSimpleName() + " is expected to declare @LinksRest", linksRest);
+        assertTrue(modelClass.getSimpleName() + " is expected to declare at least one @LinkRest",
+                linksRest.links().length > 0);
+
+        for (LinkRest linkRest : linksRest.links()) {
+            String expectedBeanName = model.getCategory() + "." + model.getTypePlural() + "." + linkRest.name();
+            try {
+                LinkRestRepository repository =
+                        utils.getLinkResourceRepository(model.getCategory(), model.getTypePlural(), linkRest.name());
+                assertNotNull("No LinkRestRepository registered as '" + expectedBeanName + "'", repository);
+            } catch (RepositoryNotFoundException e) {
+                // Translate the lookup failure into an actionable assertion. RepositoryNotFoundException
+                // reports only "<category>.<typePlural>" and never the rel, so on a model with several
+                // rels its own message cannot say which one is unregistered. It is also misleading here:
+                // it claims the repository *type* is missing when the main repository resolves fine and
+                // only the link repository bean is absent.
+                throw new AssertionError("No LinkRestRepository is registered as '" + expectedBeanName
+                        + "'. On DSpace 9 link repositories are looked up under the plural model name, so"
+                        + " the @Component of the repository serving this rel must be built from"
+                        + " PLURAL_NAME, not NAME.", e);
+            }
+        }
+    }
+
+    @Test
+    public void clarinLicenseResourceUserAllowanceRelsResolve() throws Exception {
+        // resourceMapping, userRegistration, userMetadata
+        assertAllDeclaredRelsResolve(ClarinLicenseResourceUserAllowanceRest.class);
+    }
+
+    @Test
+    public void clarinUserRegistrationRelsResolve() throws Exception {
+        // clarinLicenses, userMetadata
+        assertAllDeclaredRelsResolve(ClarinUserRegistrationRest.class);
+    }
+
+    @Test
+    public void clarinLicenseResourceMappingRelsResolve() throws Exception {
+        // clarinLicense
+        assertAllDeclaredRelsResolve(ClarinLicenseResourceMappingRest.class);
+    }
+}