cleanup

src/main/java/net/hostsharing/hsadminng/hs/booking/item/validators/HsDomainSetupBookingItemValidator.java

@@ -25,8 +25,9 @@ class HsDomainSetupBookingItemValidator extends HsBookingItemEntityValidator {
                         .notMatchesRegEx(REGISTRAR_LEVEL_DOMAINS).describedAs("is a forbidden registrar-level domain name")
                         .required(),
                 stringProperty(VERIFICATION_CODE_PROPERTY_NAME)
-                        .readOnly().initializedBy(HsDomainSetupBookingItemValidator::generateVerificationCode)
+                        .minLength(12)
-
+                        .maxLength(64)
+                        .initializedBy(HsDomainSetupBookingItemValidator::generateVerificationCode)
         );
     }
 

src/main/java/net/hostsharing/hsadminng/hs/hosting/asset/validators/HsDomainSetupHostingAssetValidator.java

@@ -13,7 +13,6 @@ import static net.hostsharing.hsadminng.hs.hosting.asset.validators.HsDomainHttp
 
 class HsDomainSetupHostingAssetValidator extends HostingAssetEntityValidator {
 
-    public static final String FQDN_REGEX = "^((?!-)[A-Za-z0-9-]{1,63}(?<!-)\\.)+[A-Za-z]{2,12}";
     public static final String DOMAIN_NAME_PROPERTY_NAME = "domainName";
 
     HsDomainSetupHostingAssetValidator() {

src/main/java/net/hostsharing/hsadminng/hs/validation/ValidatableProperty.java

@@ -266,7 +266,7 @@ public abstract class ValidatableProperty<P extends ValidatableProperty<?, ?>, T
 
     private boolean isSpecPotentiallyComplete() {
         return required == null && requiresAtLeastOneOf == null && requiresAtMaxOneOf == null && !readOnly && !writeOnly
-                && defaultValue == null;
+                && defaultValue == null && computedBy == null;
     }
 
     @SuppressWarnings("unchecked")

src/test/java/net/hostsharing/hsadminng/hs/booking/item/validators/HsDomainSetupBookingItemValidatorUnitTest.java

@@ -28,7 +28,7 @@ class HsDomainSetupBookingItemValidatorUnitTest {
     private EntityManager em;
 
     @Test
-    void acceptsRegisterableDomain() {
+    void acceptsRegisterableDomainWithGeneratedVerificationCode() {
         // given
         final var domainSetupBookingItemEntity = HsBookingItemRealEntity.builder()
                 .type(DOMAIN_SETUP)
@@ -46,6 +46,26 @@ class HsDomainSetupBookingItemValidatorUnitTest {
         assertThat(result).isEmpty();
     }
 
+    @Test
+    void acceptsRegisterableDomainWithExplicitVerifiactionCode() {
+        // given
+        final var domainSetupBookingItemEntity = HsBookingItemRealEntity.builder()
+                .type(DOMAIN_SETUP)
+                .project(project)
+                .caption("Test-Domain")
+                .resources(Map.ofEntries(
+                        entry("domainName", "example.org"),
+                        entry("verificationCode", "1234-5678-9100")
+                ))
+                .build();
+
+        // when
+        final var result = HsBookingItemEntityValidatorRegistry.doValidate(em, domainSetupBookingItemEntity);
+
+        // then
+        assertThat(result).isEmpty();
+    }
+
     @Test
     void acceptsMaximumDomainNameLength() {
         final var domainSetupBookingItemEntity = HsBookingItemRealEntity.builder()
@@ -150,6 +170,6 @@ class HsDomainSetupBookingItemValidatorUnitTest {
         // then
         assertThat(validator.properties()).map(Map::toString).containsExactlyInAnyOrder(
                 "{type=string, propertyName=domainName, matchesRegEx=[^((?!-)[A-Za-z0-9-]{1,63}(?<!-)\\.)+[A-Za-z]{2,12}], matchesRegExDescription=is not a (non-top-level) fully qualified domain name, notMatchesRegEx=[[^.]+, (co|org|gov|ac|sch)\\.uk, (com|net|org|edu|gov|asn|id)\\.au, (co|ne|or|ac|go)\\.jp, (com|net|org|gov|edu|ac)\\.cn, (com|net|org|gov|edu|mil|art)\\.br, (co|net|org|gen|firm|ind)\\.in, (com|net|org|gob|edu)\\.mx, (gov|edu)\\.it, (co|net|org|govt|ac|school|geek|kiwi)\\.nz, (co|ne|or|go|re|pe)\\.kr], notMatchesRegExDescription=is a forbidden registrar-level domain name, maxLength=253, required=true, writeOnce=true}",
-                "{type=string, propertyName=verificationCode, readOnly=true, computed=IN_INIT}");
+                "{type=string, propertyName=verificationCode, minLength=12, maxLength=64, computed=IN_INIT}");
     }
 }

src/test/java/net/hostsharing/hsadminng/hs/hosting/asset/validators/HsDomainSetupHostingAssetValidatorUnitTest.java

@@ -3,6 +3,7 @@ package net.hostsharing.hsadminng.hs.hosting.asset.validators;
 import net.hostsharing.hsadminng.hs.booking.item.HsBookingItemRealEntity;
 import net.hostsharing.hsadminng.hs.booking.item.HsBookingItemType;
 import net.hostsharing.hsadminng.hs.booking.item.validators.HsBookingItemEntityValidatorRegistry;
+import net.hostsharing.hsadminng.hs.booking.project.HsBookingProjectRealEntity;
 import net.hostsharing.hsadminng.hs.hosting.asset.HsHostingAssetRbacEntity;
 import net.hostsharing.hsadminng.hs.hosting.asset.HsHostingAssetRealEntity;
 import org.junit.jupiter.api.AfterEach;
@@ -35,8 +36,10 @@ class HsDomainSetupHostingAssetValidatorUnitTest {
     static HsHostingAssetRbacEntity.HsHostingAssetRbacEntityBuilder<?, ?> validEntityBuilder(
             final String domainName,
             final Function<HsBookingItemRealEntity.HsBookingItemRealEntityBuilder<?, ?>, HsBookingItemRealEntity> buildBookingItem) {
-        final HsBookingItemRealEntity bookingItem = buildBookingItem.apply(
+        final var project = HsBookingProjectRealEntity.builder().build();
+        final var bookingItem = buildBookingItem.apply(
                 HsBookingItemRealEntity.builder()
+                        .project(project)
                         .type(HsBookingItemType.DOMAIN_SETUP)
                         .resources(new HashMap<>(ofEntries(
                                 entry("domainName", domainName)
@@ -90,7 +93,8 @@ class HsDomainSetupHostingAssetValidatorUnitTest {
 
         // then
         assertThat(result).contains(
-                "'identifier' expected to match '(\\*|(?!-)[A-Za-z0-9-]{1,63}(?<!-))\\.example\\.org', but is '" + testCase.domainName + "'"
+                "'identifier' expected to match '(\\*|(?!-)[A-Za-z0-9-]{1,63}(?<!-))\\.example\\.org', but is '"
+                        + testCase.domainName + "'"
         );
     }
 
@@ -141,8 +145,9 @@ class HsDomainSetupHostingAssetValidatorUnitTest {
     @Test
     void validatesReferencedEntities() {
         // given
-        final var domainSetupHostingAssetEntity = validEntityBuilder("example.org",
+        final var domainSetupHostingAssetEntity = validEntityBuilder(
-                    bib -> bib.type(HsBookingItemType.CLOUD_SERVER).build())
+                "example.org",
+                bib -> bib.type(HsBookingItemType.CLOUD_SERVER).build())
                 .parentAsset(HsHostingAssetRealEntity.builder().type(CLOUD_SERVER).build())
                 .assignedToAsset(HsHostingAssetRealEntity.builder().type(MANAGED_SERVER).build())
                 .build();
@@ -161,11 +166,12 @@ class HsDomainSetupHostingAssetValidatorUnitTest {
     @Test
     void rejectsDomainNameNotMatchingBookingItemDomainName() {
         // given
-        final var domainSetupHostingAssetEntity = validEntityBuilder("not-matching-booking-item-domain-name.org",
+        final var domainSetupHostingAssetEntity = validEntityBuilder(
-                    bib -> bib.resources(new HashMap<>(ofEntries(
+                "not-matching-booking-item-domain-name.org",
-                            entry("domainName", "example.org")
+                bib -> bib.resources(new HashMap<>(ofEntries(
-                    ))).build()
+                        entry("domainName", "example.org")
-                ).build();
+                ))).build()
+        ).build();
         final var validator = HostingAssetEntityValidatorRegistry.forType(domainSetupHostingAssetEntity.getType());
 
         // when
@@ -262,6 +268,24 @@ class HsDomainSetupHostingAssetValidatorUnitTest {
 
     //=====================================================================================================================
 
+    @Test
+    void rejectsSetupOfRegistrar1stLevelDomain() {
+        domainSetupFor("org").notRegistered()
+                .isRejectedWithCauseForbidden("registrar-level domain name");
+    }
+
+    @Test
+    void rejectsSetupOfRegistrar2ndLevelDomain() {
+        domainSetupFor("co.uk").notRegistered()
+                .isRejectedWithCauseForbidden("registrar-level domain name");
+    }
+
+    @Test
+    void rejectsSetupOfHostsharingDmain() {
+        domainSetupFor("hostsharing.net").notRegistered()
+                .isRejectedWithCauseForbidden("Hostsharing domain name");
+    }
+
     @Test
     void allowSetupOfAvailableRegistrableDomain() {
         domainSetupFor("example.com").notRegistered()
@@ -416,13 +440,27 @@ class HsDomainSetupHostingAssetValidatorUnitTest {
                             + "' found for domain name '" + domainName + "'");
         }
 
+        void isRejectedWithCauseForbidden(final String type) {
+            assertThat(validate()).contains(
+                    "'D-???????:null:null.resources.domainName' = '" + domainAsset.getIdentifier() + "' is a forbidden " + type
+            );
+        }
+
         void isAccepted() {
             assertThat(validate()).isEmpty();
         }
 
         private List<String> validate() {
-            final var validator = HostingAssetEntityValidatorRegistry.forType(DOMAIN_SETUP);
+            if ( domainAsset.getBookingItem() != null ) {
-            return validator.validateEntity(domainAsset);
+                final var biValidation = HsBookingItemEntityValidatorRegistry.forType(HsBookingItemType.DOMAIN_SETUP)
+                        .validateEntity(domainAsset.getBookingItem());
+                if (!biValidation.isEmpty()) {
+                    return biValidation;
+                }
+            }
+
+            return HostingAssetEntityValidatorRegistry.forType(DOMAIN_SETUP)
+                    .validateEntity(domainAsset);
         }
     }
 
@@ -432,7 +470,10 @@ class HsDomainSetupHostingAssetValidatorUnitTest {
 
     private DomainSetupBuilder domainSetupWithParentAssetFor(final String domainName) {
         return new DomainSetupBuilder(
-                HsHostingAssetRealEntity.builder().type(DOMAIN_SETUP).identifier(Dns.superDomain(domainName).orElseThrow()).build(),
+                HsHostingAssetRealEntity.builder()
+                        .type(DOMAIN_SETUP)
+                        .identifier(Dns.superDomain(domainName).orElseThrow())
+                        .build(),
                 domainName);
     }
 }