lingwei.kong/hawkbit
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

TargetType management over common RepositoryManagement (#2581)

Browse Source 
Signed-off-by: Avgustin Marinov <Avgustin.Marinov@bosch.com>
This commit is contained in:
Avgustin Marinov
2025-08-01 19:24:49 +03:00
committed by GitHub
parent c79e35b9de
commit a689733d4c
40 changed files with 435 additions and 762 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/acm/TargetTypeAccessControllerTest.java
View File

@@ -10,6 +10,7 @@
package org.eclipse.hawkbit.repository.jpa.acm;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.eclipse.hawkbit.im.authentication.SpPermission.DELETE_TARGET_TYPE;
import static org.eclipse.hawkbit.im.authentication.SpPermission.READ_TARGET_TYPE;
@@ -18,10 +19,11 @@ import static org.eclipse.hawkbit.repository.test.util.SecurityContextSwitch.run
import static org.eclipse.hawkbit.repository.test.util.SecurityContextSwitch.withUser;
import java.util.Arrays;
import java.util.List;
import org.eclipse.hawkbit.repository.Identifiable;
import org.eclipse.hawkbit.repository.builder.TargetTypeCreate;
import org.eclipse.hawkbit.repository.builder.TargetTypeUpdate;
import org.eclipse.hawkbit.repository.TargetTypeManagement.Create;
import org.eclipse.hawkbit.repository.TargetTypeManagement.Update;
import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
import org.eclipse.hawkbit.repository.exception.InsufficientPermissionException;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
@@ -42,8 +44,8 @@ class TargetTypeAccessControllerTest extends AbstractJpaIntegrationTest {
*/
@Test
void verifyTargetTypeReadOperations() {
final TargetType permittedTargetType = targetTypeManagement.create(entityFactory.targetType().create().name("type1"));
final TargetType hiddenTargetType = targetTypeManagement.create(entityFactory.targetType().create().name("type2"));
final TargetType permittedTargetType = targetTypeManagement.create(Create.builder().name("type1").build());
final TargetType hiddenTargetType = targetTypeManagement.create(Create.builder().name("type2").build());
runAs(withUser("user", READ_TARGET_TYPE + "/id==" + permittedTargetType.getId()), () -> {
// verify targetTypeManagement#findAll
@@ -81,12 +83,13 @@ class TargetTypeAccessControllerTest extends AbstractJpaIntegrationTest {
assertThat(targetTypeManagement.getByName(hiddenTargetType.getName())).isEmpty();
// verify targetTypeManagement#get by ids
assertThat(targetTypeManagement.get(Arrays.asList(permittedTargetType.getId(), hiddenTargetTypeId))
.stream().map(Identifiable::getId).toList()).containsOnly(permittedTargetType.getId());
final List<Long> allEntityIds = Arrays.asList(permittedTargetType.getId(), hiddenTargetTypeId);
assertThatExceptionOfType(EntityNotFoundException.class).isThrownBy(() -> targetTypeManagement.get(allEntityIds));
// verify targetTypeManagement#update is not possible. Assert exception thrown.
final TargetTypeUpdate targetTypeUpdate = entityFactory.targetType().update(hiddenTargetTypeId)
.name(hiddenTargetType.getName() + "/new").description("newDesc");
final Update targetTypeUpdate = Update.builder()
.id(hiddenTargetTypeId).name(hiddenTargetType.getName() + "/new").description("newDesc")
.build();
assertThatThrownBy(() -> targetTypeManagement.update(targetTypeUpdate))
.as("Target type update shouldn't be allowed since the target type is not visible.")
.isInstanceOf(InsufficientPermissionException.class);
@@ -103,8 +106,8 @@ class TargetTypeAccessControllerTest extends AbstractJpaIntegrationTest {
*/
@Test
void verifyTargetTypeDeleteOperations() {
final TargetType manageableTargetType = targetTypeManagement.create(entityFactory.targetType().create().name("type1"));
final TargetType readOnlyTargetType = targetTypeManagement.create(entityFactory.targetType().create().name("type2"));
final TargetType manageableTargetType = targetTypeManagement.create(Create.builder().name("type1").build());
final TargetType readOnlyTargetType = targetTypeManagement.create(Create.builder().name("type2").build());
runAs(withUser("user",
READ_TARGET_TYPE + "/id==" + manageableTargetType.getId() + " or id==" + readOnlyTargetType.getId(),
@@ -124,21 +127,21 @@ class TargetTypeAccessControllerTest extends AbstractJpaIntegrationTest {
*/
@Test
void verifyTargetTypeUpdateOperations() {
final TargetType manageableTargetType = targetTypeManagement.create(entityFactory.targetType().create().name("type1"));
final TargetType readOnlyTargetType = targetTypeManagement.create(entityFactory.targetType().create().name("type2"));
final TargetType manageableTargetType = targetTypeManagement.create(Create.builder().name("type1").build());
final TargetType readOnlyTargetType = targetTypeManagement.create(Create.builder().name("type2").build());
runAs(withUser("user",
READ_TARGET_TYPE + "/id==" + manageableTargetType.getId() + " or id==" + readOnlyTargetType.getId(),
UPDATE_TARGET_TYPE + "/id==" + manageableTargetType.getId()), () -> {
// update the manageableTargetType
targetTypeManagement.update(entityFactory.targetType().update(manageableTargetType.getId())
.name(manageableTargetType.getName() + "/new").description("newDesc"));
targetTypeManagement.update(Update.builder().id(manageableTargetType.getId())
.name(manageableTargetType.getName() + "/new").description("newDesc").build());
// verify targetTypeManagement#update for readOnlyTargetType is not possible
final TargetTypeUpdate targetTypeUpdate = entityFactory.targetType().update(readOnlyTargetType.getId())
.name(readOnlyTargetType.getName() + "/new").description("newDesc");
assertThatThrownBy(() -> targetTypeManagement.update(targetTypeUpdate))
.isInstanceOf(InsufficientPermissionException.class);
final Update targetTypeUpdate = Update.builder()
.id(readOnlyTargetType.getId()).name(readOnlyTargetType.getName() + "/new").description("newDesc")
.build();
assertThatThrownBy(() -> targetTypeManagement.update(targetTypeUpdate)).isInstanceOf(InsufficientPermissionException.class);
});
}
@@ -149,7 +152,7 @@ class TargetTypeAccessControllerTest extends AbstractJpaIntegrationTest {
void verifyTargetTypeCreationBlockedByAccessController() {
runAs(withUser("user", READ_TARGET_TYPE, UPDATE_TARGET_TYPE), () -> {
// verify targetTypeManagement#create for any type
final TargetTypeCreate targetTypeCreate = entityFactory.targetType().create().name("type1");
final Create targetTypeCreate = Create.builder().name("type1").build();
assertThatThrownBy(() -> targetTypeManagement.create(targetTypeCreate))
.as("Target type create shouldn't be allowed since the target type is not visible.")
.isInstanceOf(InsufficientPermissionException.class);

19
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/autoassign/AutoAssignCheckerIntTest.java
View File

@@ -385,16 +385,15 @@ class AutoAssignCheckerIntTest extends AbstractJpaIntegrationTest {
final TargetFilterQuery testFilter = targetFilterQueryManagement.create(entityFactory.targetFilterQuery()
.create().name("test-filter").query("name==*").autoAssignDistributionSet(testDs));
final TargetType incompatibleEmptyType = testdataFactory.createTargetType("incompatibleEmptyType",
Collections.emptyList());
final TargetType incompatibleSingleType = testdataFactory.createTargetType("incompatibleSingleType",
Collections.singletonList(incompatibleDsType1));
final TargetType incompatibleMultiType = testdataFactory.createTargetType("incompatibleMultiType",
Arrays.asList(incompatibleDsType1, incompatibleDsType2));
final TargetType compatibleSingleType = testdataFactory.createTargetType("compatibleSingleType",
Collections.singletonList(testDs.getType()));
final TargetType compatibleMultiType = testdataFactory.createTargetType("compatibleMultiType",
Arrays.asList(testDs.getType(), incompatibleDsType1));
final TargetType incompatibleEmptyType = testdataFactory.createTargetType("incompatibleEmptyType", Set.of());
final TargetType incompatibleSingleType = testdataFactory.createTargetType(
"incompatibleSingleType", Set.of(incompatibleDsType1));
final TargetType incompatibleMultiType = testdataFactory.createTargetType(
"incompatibleMultiType", Set.of(incompatibleDsType1, incompatibleDsType2));
final TargetType compatibleSingleType = testdataFactory.createTargetType(
"compatibleSingleType", Set.of(testDs.getType()));
final TargetType compatibleMultiType = testdataFactory.createTargetType(
"compatibleMultiType", Set.of(testDs.getType(), incompatibleDsType1));
testdataFactory.createTargetsWithType(TARGET_COUNT, "incompatibleEmpty", incompatibleEmptyType);
testdataFactory.createTargetsWithType(TARGET_COUNT, "incompatibleSingle", incompatibleSingleType);

4
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/event/RepositoryEntityEventTest.java
View File

@@ -17,6 +17,7 @@ import java.util.concurrent.TimeUnit;
import org.assertj.core.api.Assertions;
import org.eclipse.hawkbit.repository.SoftwareModuleManagement;
import org.eclipse.hawkbit.repository.TargetTypeManagement;
import org.eclipse.hawkbit.repository.event.TenantAwareEvent;
import org.eclipse.hawkbit.repository.event.remote.DistributionSetDeletedEvent;
import org.eclipse.hawkbit.repository.event.remote.RolloutDeletedEvent;
@@ -118,8 +119,7 @@ class RepositoryEntityEventTest extends AbstractJpaIntegrationTest {
@Test
void targetTypeUpdatedEventIsPublished() throws InterruptedException {
final TargetType createdTargetType = testdataFactory.findOrCreateTargetType("targettype");
targetTypeManagement
.update(entityFactory.targetType().update(createdTargetType.getId()).name("updatedtargettype"));
targetTypeManagement.update(TargetTypeManagement.Update.builder().id(createdTargetType.getId()).name("updatedtargettype").build());
final TargetTypeUpdatedEvent targetTypeUpdatedEvent = eventListener.waitForEvent(TargetTypeUpdatedEvent.class);
assertThat(targetTypeUpdatedEvent).isNotNull();

4
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/ControllerManagementTest.java
View File

@@ -39,6 +39,7 @@ import jakarta.validation.ConstraintViolationException;
import org.assertj.core.api.Assertions;
import org.eclipse.hawkbit.im.authentication.SpPermission;
import org.eclipse.hawkbit.repository.RepositoryProperties;
import org.eclipse.hawkbit.repository.TargetTypeManagement;
import org.eclipse.hawkbit.repository.UpdateMode;
import org.eclipse.hawkbit.repository.builder.ActionStatusCreate;
import org.eclipse.hawkbit.repository.event.remote.CancelTargetAssignmentEvent;
@@ -1829,7 +1830,8 @@ class ControllerManagementTest extends AbstractJpaIntegrationTest {
}
private void createTargetType(String targetTypeName) {
systemSecurityContext.runAsSystem(() -> targetTypeManagement.create(entityFactory.targetType().create().name(targetTypeName)));
systemSecurityContext.runAsSystem(
() -> targetTypeManagement.create(TargetTypeManagement.Create.builder().name(targetTypeName).build()));
}
private void addAttributeAndVerify(final String controllerId) {

20
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/DeploymentManagementTest.java
View File

@@ -1608,8 +1608,7 @@ class DeploymentManagementTest extends AbstractJpaIntegrationTest {
@Test
void verifyDSAssignmentForMultipleTargetsWithSameTargetType() {
final DistributionSet ds = testdataFactory.createDistributionSet("test-ds");
final TargetType targetType = testdataFactory.createTargetType("test-type",
Collections.singletonList(ds.getType()));
final TargetType targetType = testdataFactory.createTargetType("test-type", Set.of(ds.getType()));
final List<DeploymentRequest> deploymentRequests = new ArrayList<>();
for (int i = 0; i < quotaManagement.getMaxTargetDistributionSetAssignmentsPerManualAssignment(); i++) {
@@ -1635,8 +1634,8 @@ class DeploymentManagementTest extends AbstractJpaIntegrationTest {
@Test
void verifyDSAssignmentForMultipleTargetsWithDifferentTargetTypes() {
final DistributionSet ds = testdataFactory.createDistributionSet("test-ds");
final TargetType targetType1 = testdataFactory.createTargetType("test-type1", Collections.singletonList(ds.getType()));
final TargetType targetType2 = testdataFactory.createTargetType("test-type2", Collections.singletonList(ds.getType()));
final TargetType targetType1 = testdataFactory.createTargetType("test-type1", Set.of(ds.getType()));
final TargetType targetType2 = testdataFactory.createTargetType("test-type2", Set.of(ds.getType()));
final Target target1 = testdataFactory.createTarget("test-target1", "test-target1", targetType1.getId());
final Target target2 = testdataFactory.createTarget("test-target2", "test-target2", targetType2.getId());
@@ -1663,13 +1662,11 @@ class DeploymentManagementTest extends AbstractJpaIntegrationTest {
void verifyDSAssignmentFailsForTargetsWithIncompatibleTargetTypes() {
final DistributionSet ds = testdataFactory.createDistributionSet("test-ds");
final DistributionSetType dsType = testdataFactory.findOrCreateDistributionSetType("test-ds-type", "dsType");
final TargetType targetType = testdataFactory.createTargetType("target-type",
Collections.singletonList(dsType));
final TargetType targetType = testdataFactory.createTargetType("target-type", Set.of(dsType));
final Target target = testdataFactory.createTarget("test-target", "test-target", targetType.getId());
final DeploymentRequest deploymentRequest = DeploymentManagement
.deploymentRequest(target.getControllerId(), ds.getId()).build();
final List<DeploymentRequest> deploymentRequests = Collections.singletonList(deploymentRequest);
final DeploymentRequest deploymentRequest = DeploymentManagement.deploymentRequest(target.getControllerId(), ds.getId()).build();
final List<DeploymentRequest> deploymentRequests = List.of(deploymentRequest);
assertThatExceptionOfType(IncompatibleTargetTypeException.class)
.isThrownBy(() -> deploymentManagement.assignDistributionSets(deploymentRequests));
@@ -1681,9 +1678,8 @@ class DeploymentManagementTest extends AbstractJpaIntegrationTest {
@Test
void verifyDSAssignmentFailsForTargetsWithTargetTypesThatAreNotCompatibleWithAnyDs() {
final DistributionSet ds = testdataFactory.createDistributionSet("test-ds");
final TargetType emptyTargetType = testdataFactory.createTargetType("target-type", Collections.emptyList());
final Target targetWithEmptyType = testdataFactory.createTarget("test-target", "test-target",
emptyTargetType.getId());
final TargetType emptyTargetType = testdataFactory.createTargetType("target-type", Set.of());
final Target targetWithEmptyType = testdataFactory.createTarget("test-target", "test-target", emptyTargetType.getId());
final DeploymentRequest deploymentRequestWithEmptyType = DeploymentManagement
.deploymentRequest(targetWithEmptyType.getControllerId(), ds.getId()).build();

27
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/RolloutManagementTest.java
View File

@@ -21,6 +21,7 @@ import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
@@ -288,7 +289,7 @@ class RolloutManagementTest extends AbstractJpaIntegrationTest {
}
/**
* Verifies that management get access reacts as specified on calls for non existing entities by means
* Verifies that management get access reacts as specified on calls for non existing entities by means
* of Optional not present.
*/
@Test
@@ -300,8 +301,8 @@ class RolloutManagementTest extends AbstractJpaIntegrationTest {
}
/**
* Verifies that management queries react as specified on calls for non existing entities
* by means of throwing EntityNotFoundException.
* Verifies that management queries react as specified on calls for non existing entities
* by means of throwing EntityNotFoundException.
*/
@Test
@ExpectEvents({
@@ -1822,7 +1823,7 @@ class RolloutManagementTest extends AbstractJpaIntegrationTest {
}
/**
* Creating a rollout with approval role or approval engine disabled results in the rollout being in
* Creating a rollout with approval role or approval engine disabled results in the rollout being in
* READY state.
*/
@Test
@@ -1837,7 +1838,7 @@ class RolloutManagementTest extends AbstractJpaIntegrationTest {
}
/**
* Creating a rollout without approve role and approval enabled leads to transition to
* Creating a rollout without approve role and approval enabled leads to transition to
* WAITING_FOR_APPROVAL state.
*/
@Test
@@ -2147,21 +2148,17 @@ class RolloutManagementTest extends AbstractJpaIntegrationTest {
final String rolloutName = "rolloutTestCompatibility";
final DistributionSet testDs = testdataFactory.createDistributionSet("test-ds");
final TargetType incompatibleTargetType = testdataFactory.createTargetType("incompatible-type",
Collections.emptyList());
final TargetType compatibleTargetType = testdataFactory.createTargetType("compatible-type",
Collections.singletonList(testDs.getType()));
final TargetType incompatibleTargetType = testdataFactory.createTargetType("incompatible-type", Set.of());
final TargetType compatibleTargetType = testdataFactory.createTargetType("compatible-type", Set.of(testDs.getType()));
final List<Target> incompatibleTargets = testdataFactory.createTargetsWithType(10, "incompatible",
incompatibleTargetType);
final List<Target> incompatibleTargets = testdataFactory.createTargetsWithType(10, "incompatible", incompatibleTargetType);
final List<Target> targetsWithoutType = testdataFactory.createTargets(10, "testTarget-");
final List<Target> targets = testdataFactory.createTargetsWithType(10, "compatibleTarget-",
compatibleTargetType);
final List<Target> targets = testdataFactory.createTargetsWithType(10, "compatibleTarget-", compatibleTargetType);
targets.addAll(targetsWithoutType);
final RolloutGroupConditions conditions = new RolloutGroupConditionBuilder().withDefaults().build();
final RolloutCreate rolloutToCreate = entityFactory.rollout().create().name(rolloutName)
.targetFilterQuery("name==*").distributionSetId(testDs);
final RolloutCreate rolloutToCreate = entityFactory.rollout().create()
.name(rolloutName).targetFilterQuery("name==*").distributionSetId(testDs);
final Rollout createdRollout = rolloutManagement.create(rolloutToCreate, 1, false, conditions);

42
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/SoftwareModuleTypeManagementTest.java
View File

@@ -20,6 +20,7 @@ import jakarta.validation.ConstraintViolationException;
import org.assertj.core.api.Assertions;
import org.eclipse.hawkbit.repository.SoftwareModuleManagement;
import org.eclipse.hawkbit.repository.SoftwareModuleTypeManagement;
import org.eclipse.hawkbit.repository.SoftwareModuleTypeManagement.Create;
import org.eclipse.hawkbit.repository.event.remote.entity.SoftwareModuleCreatedEvent;
import org.eclipse.hawkbit.repository.exception.EntityAlreadyExistsException;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
@@ -67,11 +68,10 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void updateNothingResultsInUnchangedRepositoryForType() {
final SoftwareModuleType created = softwareModuleTypeManagement
.create(SoftwareModuleTypeManagement.Create.builder().key("test-key").name("test-name").build());
final SoftwareModuleType created = softwareModuleTypeManagement.create(Create.builder().key("test-key").name("test-name").build());
final SoftwareModuleType updated = softwareModuleTypeManagement
.update(SoftwareModuleTypeManagement.Update.builder().id(created.getId()).build());
final SoftwareModuleType updated = softwareModuleTypeManagement.update(SoftwareModuleTypeManagement.Update.builder().id(created.getId())
.build());
assertThat(updated.getOptLockRevision())
.as("Expected version number of updated entitity to be equal to created version")
@@ -84,7 +84,7 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
@Test
void updateSoftwareModuleTypeFieldsToNewValue() {
final SoftwareModuleType created = softwareModuleTypeManagement
.create(SoftwareModuleTypeManagement.Create.builder().key("test-key").name("test-name").build());
.create(Create.builder().key("test-key").name("test-name").build());
final SoftwareModuleType updated = softwareModuleTypeManagement.update(
SoftwareModuleTypeManagement.Update.builder().id(created.getId()).description("changed").colour("changed").build());
@@ -100,9 +100,9 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void createModuleTypesCallFailsForExistingTypes() {
final List<SoftwareModuleTypeManagement.Create> created = Arrays.asList(
SoftwareModuleTypeManagement.Create.builder().key("test-key").name("test-name").build(),
SoftwareModuleTypeManagement.Create.builder().key("test-key2").name("test-name2").build());
final List<Create> created = Arrays.asList(
Create.builder().key("test-key").name("test-name").build(),
Create.builder().key("test-key2").name("test-name2").build());
softwareModuleTypeManagement.create(created);
assertThatExceptionOfType(EntityAlreadyExistsException.class)
.as("should not have worked as module type already exists")
@@ -117,7 +117,7 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
Assertions.<SoftwareModuleType>assertThat(softwareModuleTypeManagement.findAll(PAGE)).hasSize(3).contains(osType, runtimeType, appType);
SoftwareModuleType type = softwareModuleTypeManagement
.create(SoftwareModuleTypeManagement.Create.builder().key("bundle").name("OSGi Bundle").build());
.create(Create.builder().key("bundle").name("OSGi Bundle").build());
Assertions.<SoftwareModuleType>assertThat(softwareModuleTypeManagement.findAll(PAGE)).hasSize(4).contains(osType, runtimeType, appType, type);
@@ -127,7 +127,7 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
Assertions.<SoftwareModuleType>assertThat(softwareModuleTypeRepository.findAll()).hasSize(3).contains(osType, runtimeType, appType);
type = softwareModuleTypeManagement
.create(SoftwareModuleTypeManagement.Create.builder().key("bundle2").name("OSGi Bundle2").build());
.create(Create.builder().key("bundle2").name("OSGi Bundle2").build());
Assertions.<SoftwareModuleType>assertThat(softwareModuleTypeManagement.findAll(PAGE)).hasSize(4).contains(osType, runtimeType, appType, type);
@@ -152,9 +152,9 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
void findSoftwareModuleTypeByName() {
testdataFactory.createSoftwareModuleOs();
final SoftwareModuleType found = softwareModuleTypeManagement
.create(SoftwareModuleTypeManagement.Create.builder().key("thetype").name("thename").build());
.create(Create.builder().key("thetype").name("thename").build());
softwareModuleTypeManagement
.create(SoftwareModuleTypeManagement.Create.builder().key("thetype2").name("anothername").build());
.create(Create.builder().key("thetype2").name("anothername").build());
Assertions.<SoftwareModuleType>assertThat(((SoftwareModuleTypeManagement<SoftwareModuleType>) softwareModuleTypeManagement).findByName("thename"))
.as("Type with given name").contains(found);
@@ -165,7 +165,7 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void createSoftwareModuleTypeFailsWithExistingEntity() {
final SoftwareModuleTypeManagement.Create create = SoftwareModuleTypeManagement.Create.builder().key("thetype").name("thename").build();
final Create create = Create.builder().key("thetype").name("thename").build();
softwareModuleTypeManagement.create(create);
assertThatExceptionOfType(EntityAlreadyExistsException.class)
.as("should not have worked as module type already exists")
@@ -177,10 +177,10 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void createSoftwareModuleTypesFailsWithExistingEntity() {
softwareModuleTypeManagement.create(SoftwareModuleTypeManagement.Create.builder().key("thetype").name("thename").build());
final List<SoftwareModuleTypeManagement.Create> creates = List.of(
SoftwareModuleTypeManagement.Create.builder().key("thetype").name("thename").build(),
SoftwareModuleTypeManagement.Create.builder().key("anothertype").name("anothername").build());
softwareModuleTypeManagement.create(Create.builder().key("thetype").name("thename").build());
final List<Create> creates = List.of(
Create.builder().key("thetype").name("thename").build(),
Create.builder().key("anothertype").name("anothername").build());
assertThatExceptionOfType(EntityAlreadyExistsException.class)
.as("should not have worked as module type already exists")
.isThrownBy(() -> softwareModuleTypeManagement.create(creates));
@@ -191,8 +191,8 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void createSoftwareModuleTypesFailsWithInvalidMaxAssignment() {
final SoftwareModuleTypeManagement.Create create =
SoftwareModuleTypeManagement.Create.builder().key("type").name("name").maxAssignments(0).build();
final Create create =
Create.builder().key("type").name("name").maxAssignments(0).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("should not have worked as max assignment is invalid. Should be greater than 0")
.isThrownBy(() -> softwareModuleTypeManagement.create(create));
@@ -205,8 +205,8 @@ class SoftwareModuleTypeManagementTest extends AbstractJpaIntegrationTest {
void createMultipleSoftwareModuleTypes() {
final List<? extends SoftwareModuleType> created = softwareModuleTypeManagement
.create(List.of(
SoftwareModuleTypeManagement.Create.builder().key("thetype").name("thename").build(),
SoftwareModuleTypeManagement.Create.builder().key("thetype2").name("thename2").build()));
Create.builder().key("thetype").name("thename").build(),
Create.builder().key("thetype2").name("thename2").build()));
assertThat(created).as("Number of created types").hasSize(2);
assertThat(softwareModuleTypeManagement.count()).as("Number of types in repository").isEqualTo(5);

14
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/TargetManagementSearchTest.java
View File

@@ -15,6 +15,7 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.eclipse.hawkbit.repository.DistributionSetManagement;
import org.eclipse.hawkbit.repository.FilterParams;
@@ -43,8 +44,7 @@ class TargetManagementSearchTest extends AbstractJpaIntegrationTest {
*/
@Test
void findTargetByTargetType() {
final TargetType testType = testdataFactory.createTargetType("testType",
Collections.singletonList(standardDsType));
final TargetType testType = testdataFactory.createTargetType("testType", Set.of(standardDsType));
final List<Target> unassigned = testdataFactory.createTargets(9, "unassigned");
final List<Target> assigned = testdataFactory.createTargetsWithType(11, "assigned", testType);
@@ -76,8 +76,7 @@ class TargetManagementSearchTest extends AbstractJpaIntegrationTest {
final DistributionSet setA = testdataFactory.createDistributionSet("A");
final DistributionSet setB = testdataFactory.createDistributionSet("B");
final TargetType targetTypeX = testdataFactory.createTargetType("TargetTypeX",
Collections.singletonList(setB.getType()));
final TargetType targetTypeX = testdataFactory.createTargetType("TargetTypeX", Set.of(setB.getType()));
final DistributionSet installedSet = testdataFactory.createDistributionSet("another");
@@ -259,8 +258,7 @@ class TargetManagementSearchTest extends AbstractJpaIntegrationTest {
@Test
void shouldFindAllTargetsCompatibleWithDS() {
final DistributionSet testDs = testdataFactory.createDistributionSet();
final TargetType targetType = testdataFactory.createTargetType("testType",
Collections.singletonList(testDs.getType()));
final TargetType targetType = testdataFactory.createTargetType("testType", Set.of(testDs.getType()));
final TargetFilterQuery tfq = targetFilterQueryManagement
.create(entityFactory.targetFilterQuery().create().name("test-filter").query("name==*"));
final List<Target> targets = testdataFactory.createTargets(20, "withOutType");
@@ -282,9 +280,9 @@ class TargetManagementSearchTest extends AbstractJpaIntegrationTest {
final DistributionSetType dsType = testdataFactory.findOrCreateDistributionSetType("test-ds-type", "test-ds-type");
final DistributionSet testDs = distributionSetManagement.create(DistributionSetManagement.Create.builder()
.type(dsType).name("test-ds").version("1.0").build());
final TargetType compatibleTargetType = testdataFactory.createTargetType("compTestType", List.of(dsType));
final TargetType compatibleTargetType = testdataFactory.createTargetType("compTestType", Set.of(dsType));
final TargetType incompatibleTargetType = testdataFactory.createTargetType(
"incompTestType", List.of(testdataFactory.createDistributionSet().getType()));
"incompTestType", Set.of(testdataFactory.createDistributionSet().getType()));
final TargetFilterQuery tfq = targetFilterQueryManagement
.create(entityFactory.targetFilterQuery().create().name("test-filter").query("name==*"));

15
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/TargetManagementTest.java
View File

@@ -24,6 +24,7 @@ import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Set;
import jakarta.validation.ConstraintViolationException;
@@ -515,12 +516,12 @@ class TargetManagementTest extends AbstractJpaIntegrationTest {
final Target t1 = testdataFactory.createTarget("id-1");
final int noT2Tags = 4;
final int noT1Tags = 3;
final List<TargetTag> t1Tags = testdataFactory.createTargetTags(noT1Tags, "tag1");
final List<? extends TargetTag> t1Tags = testdataFactory.createTargetTags(noT1Tags, "tag1");
t1Tags.forEach(tag -> targetManagement.assignTag(Collections.singletonList(t1.getControllerId()), tag.getId()));
final Target t2 = testdataFactory.createTarget("id-2");
final List<TargetTag> t2Tags = testdataFactory.createTargetTags(noT2Tags, "tag2");
final List<? extends TargetTag> t2Tags = testdataFactory.createTargetTags(noT2Tags, "tag2");
t2Tags.forEach(tag -> targetManagement.assignTag(Collections.singletonList(t2.getControllerId()), tag.getId()));
final Target t11 = targetManagement.getByControllerID(t1.getControllerId())
@@ -889,7 +890,7 @@ class TargetManagementTest extends AbstractJpaIntegrationTest {
@WithUser(allSpPermissions = true)
void createAndUpdateTargetTypeInTarget() {
// create a target type
final List<TargetType> targetTypes = testdataFactory.createTargetTypes("targettype", 2);
final List<? extends TargetType> targetTypes = testdataFactory.createTargetTypes("targettype", 2);
assertThat(targetTypes).hasSize(2);
// create a target
final Target target = testdataFactory.createTarget("target1", "testtarget", targetTypes.get(0).getId());
@@ -963,8 +964,8 @@ class TargetManagementTest extends AbstractJpaIntegrationTest {
final List<Target> typeBTargets = testdataFactory.createTargets(10, "typeBTargets", "first description");
// create a target type
final TargetType typeA = testdataFactory.createTargetType("A", Collections.singletonList(standardDsType));
final TargetType typeB = testdataFactory.createTargetType("B", Collections.singletonList(standardDsType));
final TargetType typeA = testdataFactory.createTargetType("A", Set.of(standardDsType));
final TargetType typeB = testdataFactory.createTargetType("B", Set.of(standardDsType));
// assign target type to target
TargetTypeAssignmentResult resultA = initiateTypeAssignment(typeATargets, typeA);
@@ -1088,7 +1089,7 @@ class TargetManagementTest extends AbstractJpaIntegrationTest {
final String controllerId1 = "target1";
final String controllerId2 = "target2";
createTargetWithMetadata(controllerId1, 2);
final TargetType type = testdataFactory.createTargetType("type1", Collections.emptyList());
final TargetType type = testdataFactory.createTargetType("type1", Set.of());
createTargetWithTargetTypeAndMetadata(controllerId2, type.getId(), 2);
assertThat(targetManagement.count()).as("Total targets").isEqualTo(2);
@@ -1147,7 +1148,7 @@ class TargetManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void matchesFilterWrongType() {
final TargetType type = testdataFactory.createTargetType("type", Collections.emptyList());
final TargetType type = testdataFactory.createTargetType("type", Set.of());
final Target target = testdataFactory.createTarget("target", "target", type.getId());
final DistributionSet ds = testdataFactory.createDistributionSet();

2
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/TargetTagManagementTest.java
View File

@@ -319,7 +319,7 @@ class TargetTagManagementTest extends AbstractJpaIntegrationTest {
private List<JpaTargetTag> createTargetsWithTags() {
final List<Target> targets = testdataFactory.createTargets(20);
final Iterable<TargetTag> tags = testdataFactory.createTargetTags(20, "");
final Iterable<? extends TargetTag> tags = testdataFactory.createTargetTags(20, "");
tags.forEach(tag -> assignTag(targets, tag));

9
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/TargetTypeManagementSecurityTest.java
View File

@@ -13,6 +13,9 @@ import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.hawkbit.im.authentication.SpPermission;
import org.eclipse.hawkbit.repository.TargetTypeManagement;
import org.eclipse.hawkbit.repository.TargetTypeManagement.Create;
import org.eclipse.hawkbit.repository.TargetTypeManagement.Update;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.test.util.WithUser;
import org.junit.jupiter.api.Test;
@@ -61,7 +64,7 @@ class TargetTypeManagementSecurityTest extends AbstractJpaIntegrationTest {
*/
@Test
void createPermissionsCheck() {
assertPermissions(() -> targetTypeManagement.create(entityFactory.targetType().create().name("name")),
assertPermissions(() -> targetTypeManagement.create(Create.builder().name("name").build()),
List.of(SpPermission.CREATE_TARGET));
}
@@ -70,7 +73,7 @@ class TargetTypeManagementSecurityTest extends AbstractJpaIntegrationTest {
*/
@Test
void createCollectionPermissionsCheck() {
assertPermissions(() -> targetTypeManagement.create(List.of(entityFactory.targetType().create().name("name"))),
assertPermissions(() -> targetTypeManagement.create(List.of(Create.builder().name("name").build())),
List.of(SpPermission.CREATE_TARGET));
}
@@ -130,7 +133,7 @@ class TargetTypeManagementSecurityTest extends AbstractJpaIntegrationTest {
*/
@Test
void updatePermissionsCheck() {
assertPermissions(() -> targetTypeManagement.update(entityFactory.targetType().update(1L)), List.of(SpPermission.UPDATE_TARGET));
assertPermissions(() -> targetTypeManagement.update(Update.builder().id(1L).build()), List.of(SpPermission.UPDATE_TARGET));
}
/**

91
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/management/TargetTypeManagementTest.java
View File

@@ -18,8 +18,8 @@ import java.util.Optional;
import jakarta.validation.ConstraintViolationException;
import org.eclipse.hawkbit.repository.builder.TargetTypeCreate;
import org.eclipse.hawkbit.repository.builder.TargetTypeUpdate;
import org.eclipse.hawkbit.repository.TargetTypeManagement.Create;
import org.eclipse.hawkbit.repository.TargetTypeManagement.Update;
import org.eclipse.hawkbit.repository.event.remote.entity.TargetTypeCreatedEvent;
import org.eclipse.hawkbit.repository.event.remote.entity.TargetTypeUpdatedEvent;
import org.eclipse.hawkbit.repository.exception.EntityAlreadyExistsException;
@@ -58,8 +58,7 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
@ExpectEvents({ @Expect(type = TargetTypeUpdatedEvent.class) })
void entityQueriesReferringToNotExistingEntitiesThrowsException() {
verifyThrownExceptionBy(() -> targetTypeManagement.delete(NOT_EXIST_IDL), "TargetType");
verifyThrownExceptionBy(() -> targetTypeManagement.update(entityFactory.targetType().update(NOT_EXIST_IDL)),
"TargetType");
verifyThrownExceptionBy(() -> targetTypeManagement.update(Update.builder().id(NOT_EXIST_IDL).build()),"TargetType");
}
/**
@@ -68,9 +67,7 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
@Test
void createAndUpdateTargetTypeWithInvalidFields() {
final TargetType targetType = targetTypeManagement
.create(entityFactory.targetType().create()
.name("targettype1").description("targettypedes1")
.key("targettype1.key"));
.create(Create.builder().name("targettype1").description("targettypedes1").key("targettype1.key").build());
createAndUpdateTargetTypeWithInvalidDescription(targetType);
createAndUpdateTargetTypeWithInvalidColour(targetType);
@@ -79,23 +76,24 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
}
void createAndUpdateTargetTypeWithInvalidDescription(final TargetType targetType) {
final TargetTypeCreate targetTypeCreateTooLong = entityFactory.targetType().create().name("a").description(randomString(TargetType.DESCRIPTION_MAX_SIZE + 1));
final Create targetTypeCreateTooLong = Create.builder()
.name("a").description(randomString(TargetType.DESCRIPTION_MAX_SIZE + 1)).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too long description should not be created")
.isThrownBy(() -> targetTypeManagement.create(targetTypeCreateTooLong));
final TargetTypeCreate targetTypeCreateInvalidHtml = entityFactory.targetType().create().name("a").description(INVALID_TEXT_HTML);
final Create targetTypeCreateInvalidHtml = Create.builder().name("a").description(INVALID_TEXT_HTML).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with invalid description should not be created")
.isThrownBy(() -> targetTypeManagement.create(targetTypeCreateInvalidHtml));
final TargetTypeUpdate targetTypeUpdateTooLong = entityFactory.targetType().update(targetType.getId())
.description(randomString(TargetType.DESCRIPTION_MAX_SIZE + 1));
final Update targetTypeUpdateTooLong = Update.builder().id(targetType.getId())
.description(randomString(TargetType.DESCRIPTION_MAX_SIZE + 1)).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too long description should not be updated")
.isThrownBy(() -> targetTypeManagement.update(targetTypeUpdateTooLong));
final TargetTypeUpdate targetTypeUpdateInvalidHtml = entityFactory.targetType().update(targetType.getId()).description(INVALID_TEXT_HTML);
final Update targetTypeUpdateInvalidHtml = Update.builder().id(targetType.getId()).description(INVALID_TEXT_HTML).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with invalid description should not be updated")
.isThrownBy(() -> targetTypeManagement.update(targetTypeUpdateInvalidHtml));
@@ -107,15 +105,14 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
@Test
void assignCompatibleDistributionSetTypesToTargetType() {
final TargetType targetType = targetTypeManagement
.create(entityFactory.targetType().create()
.name("targettype1").description("targettypedes1")
.key("targettyp1.key"));
.create(Create.builder()
.name("targettype1").description("targettypedes1").key("targettyp1.key").build());
DistributionSetType distributionSetType = testdataFactory.findOrCreateDistributionSetType("testDst", "dst1");
targetTypeManagement.assignCompatibleDistributionSetTypes(targetType.getId(), Collections.singletonList(distributionSetType.getId()));
Optional<JpaTargetType> targetTypeWithDsTypes = targetTypeRepository.findById(targetType.getId());
assertThat(targetTypeWithDsTypes).isPresent();
assertThat(targetTypeWithDsTypes.get().getCompatibleDistributionSetTypes()).extracting("key").contains("testDst");
assertThat(targetTypeWithDsTypes.get().getDistributionSetTypes()).extracting("key").contains("testDst");
}
/**
@@ -124,18 +121,16 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
@Test
void unassignCompatibleDistributionSetTypesToTargetType() {
final TargetType targetType = targetTypeManagement
.create(entityFactory.targetType().create()
.name("targettype1").description("targettypedes1")
.key("targettyp1.key"));
.create(Create.builder().name("targettype1").description("targettypedes1").key("targettyp1.key").build());
DistributionSetType distributionSetType = testdataFactory.findOrCreateDistributionSetType("testDst1", "dst11");
targetTypeManagement.assignCompatibleDistributionSetTypes(targetType.getId(), Collections.singletonList(distributionSetType.getId()));
Optional<JpaTargetType> targetTypeWithDsTypes = targetTypeRepository.findById(targetType.getId());
assertThat(targetTypeWithDsTypes).isPresent();
assertThat(targetTypeWithDsTypes.get().getCompatibleDistributionSetTypes()).extracting("key").contains("testDst1");
assertThat(targetTypeWithDsTypes.get().getDistributionSetTypes()).extracting("key").contains("testDst1");
targetTypeManagement.unassignDistributionSetType(targetType.getId(), distributionSetType.getId());
Optional<JpaTargetType> targetTypeWithDsTypes1 = targetTypeRepository.findById(targetType.getId());
assertThat(targetTypeWithDsTypes1).isPresent();
assertThat(targetTypeWithDsTypes1.get().getCompatibleDistributionSetTypes()).isEmpty();
assertThat(targetTypeWithDsTypes1.get().getDistributionSetTypes()).isEmpty();
}
/**
@@ -154,12 +149,7 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
void createTargetType() {
final String name = "targettype1";
final String key = "targettype1.key";
targetTypeManagement
.create(entityFactory.targetType().create()
.name(name)
.description("targettypedes1")
.key(key)
.colour("colour1"));
targetTypeManagement.create(Create.builder().name(name).description("targettypedes1").key(key).colour("colour1").build());
assertThat(findByName(name).map(JpaTargetType::getName).orElse(null)).as("type found (name)")
.isEqualTo(name);
@@ -185,10 +175,8 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
@Test
void deleteTargetType() {
// create test data
final TargetType targetType = targetTypeManagement
.create(entityFactory.targetType().create().name("targettype11").description("targettypedes11"));
assertThat(findByName("targettype11").get().getDescription()).as("type found")
.isEqualTo("targettypedes11");
final TargetType targetType = targetTypeManagement.create(Create.builder().name("targettype11").description("targettypedes11").build());
assertThat(findByName("targettype11").get().getDescription()).as("type found").isEqualTo("targettypedes11");
targetTypeManagement.delete(targetType.getId());
assertThat(targetTypeRepository.findById(targetType.getId())).as("No target type should be found").isNotPresent();
@@ -199,11 +187,10 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void updateTargetType() {
final TargetType targetType = targetTypeManagement
.create(entityFactory.targetType().create().name("targettype111").description("targettypedes111"));
assertThat(findByName("targettype111").get().getDescription()).as("type found")
.isEqualTo("targettypedes111");
targetTypeManagement.update(entityFactory.targetType().update(targetType.getId()).name("updatedtargettype111"));
final TargetType targetType =
targetTypeManagement.create(Create.builder().name("targettype111").description("targettypedes111").build());
assertThat(findByName("targettype111").get().getDescription()).as("type found").isEqualTo("targettypedes111");
targetTypeManagement.update(Update.builder().id(targetType.getId()).name("updatedtargettype111").build());
assertThat(findByName("updatedtargettype111")).as("Updated target type should be found").isPresent();
}
@@ -212,7 +199,7 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void failedDuplicateTargetTypeNameException() {
final TargetTypeCreate targetTypeCreate = entityFactory.targetType().create().name("targettype123");
final Create targetTypeCreate = Create.builder().name("targettype123").build();
targetTypeManagement.create(targetTypeCreate);
assertThrows(EntityAlreadyExistsException.class, () -> targetTypeManagement.create(targetTypeCreate));
}
@@ -222,69 +209,71 @@ class TargetTypeManagementTest extends AbstractJpaIntegrationTest {
*/
@Test
void failedDuplicateTargetTypeNameExceptionAfterUpdate() {
targetTypeManagement.create(entityFactory.targetType().create().name("targettype1234"));
TargetType targetType = targetTypeManagement.create(entityFactory.targetType().create().name("targettype12345"));
targetTypeManagement.create(Create.builder().name("targettype1234").build());
TargetType targetType = targetTypeManagement.create(Create.builder().name("targettype12345").build());
assertThrows(EntityAlreadyExistsException.class,
() -> targetTypeManagement.update(entityFactory.targetType().update(targetType.getId()).name("targettype1234")));
() -> targetTypeManagement.update(Update.builder().id(targetType.getId()).name("targettype1234").build()));
}
private void createAndUpdateTargetTypeWithInvalidColour(final TargetType targetType) {
final TargetTypeCreate targetTypeCreateTooLong = entityFactory.targetType().create().name("a").colour(randomString(Type.COLOUR_MAX_SIZE + 1));
final Create targetTypeCreateTooLong = Create.builder().name("a").colour(randomString(Type.COLOUR_MAX_SIZE + 1)).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too long colour should not be created")
.isThrownBy(() -> targetTypeManagement.create(targetTypeCreateTooLong));
final TargetTypeCreate targetTypeCreateInvalidHtml = entityFactory.targetType().create().name("a").colour(INVALID_TEXT_HTML);
final Create targetTypeCreateInvalidHtml = Create.builder().name("a").colour(INVALID_TEXT_HTML).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with invalid colour should not be created")
.isThrownBy(() -> targetTypeManagement.create(targetTypeCreateInvalidHtml));
final TargetTypeUpdate targetTypeUpdateTooLong = entityFactory.targetType().update(targetType.getId()).colour(randomString(Type.COLOUR_MAX_SIZE + 1));
final Update targetTypeUpdateTooLong = Update.builder()
.id(targetType.getId()).colour(randomString(Type.COLOUR_MAX_SIZE + 1)).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too long colour should not be updated")
.isThrownBy(() -> targetTypeManagement.update(targetTypeUpdateTooLong));
final TargetTypeUpdate targetTypeUpdateInvalidHtml = entityFactory.targetType().update(targetType.getId()).colour(INVALID_TEXT_HTML);
final Update targetTypeUpdateInvalidHtml = Update.builder().id(targetType.getId()).colour(INVALID_TEXT_HTML).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with invalid colour should not be updated")
.isThrownBy(() -> targetTypeManagement.update(targetTypeUpdateInvalidHtml));
}
private void createTargetTypeWithInvalidKey() {
final TargetTypeCreate targetTypeCreateTooLong = entityFactory.targetType().create().name(randomString(Type.KEY_MAX_SIZE + 1));
final Create targetTypeCreateTooLong = Create.builder().name(randomString(Type.KEY_MAX_SIZE + 1)).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too long key should not be created")
.isThrownBy(() -> targetTypeManagement.create(targetTypeCreateTooLong));
final TargetTypeCreate targetTypeCreateInvalidHtmle = entityFactory.targetType().create().name(INVALID_TEXT_HTML);
final Create targetTypeCreateInvalidHtmle = Create.builder().name(INVALID_TEXT_HTML).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with invalid key should not be created")
.isThrownBy(() -> targetTypeManagement.create(targetTypeCreateInvalidHtmle));
}
private void createAndUpdateTargetTypeWithInvalidName(final TargetType targetType) {
final TargetTypeCreate targetTypeCreateTooLong = entityFactory.targetType().create().name(randomString(NamedEntity.NAME_MAX_SIZE + 1));
final Create targetTypeCreateTooLong = Create.builder().name(randomString(NamedEntity.NAME_MAX_SIZE + 1)).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too long name should not be created")
.isThrownBy(() -> targetTypeManagement
.create(targetTypeCreateTooLong));
final TargetTypeCreate targetTypeCreateInvalidHtml = entityFactory.targetType().create().name(INVALID_TEXT_HTML);
final Create targetTypeCreateInvalidHtml = Create.builder().name(INVALID_TEXT_HTML).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with invalid name should not be created")
.isThrownBy(() -> targetTypeManagement.create(targetTypeCreateInvalidHtml));
final TargetTypeUpdate targetTypeUpdateTooLong = entityFactory.targetType().update(targetType.getId()).name(randomString(NamedEntity.NAME_MAX_SIZE + 1));
final Update targetTypeUpdateTooLong = Update.builder()
.id(targetType.getId()).name(randomString(NamedEntity.NAME_MAX_SIZE + 1)).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too long name should not be updated")
.isThrownBy(() -> targetTypeManagement.update(targetTypeUpdateTooLong));
final TargetTypeUpdate targetTypeUpdateInvalidHtml = entityFactory.targetType().update(targetType.getId()).name(INVALID_TEXT_HTML);
final Update targetTypeUpdateInvalidHtml = Update.builder().id(targetType.getId()).name(INVALID_TEXT_HTML).build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with invalid name should not be updated")
.isThrownBy(() -> targetTypeManagement.update(targetTypeUpdateInvalidHtml));
final TargetTypeUpdate targetTypeUpdateEmpty = entityFactory.targetType().update(targetType.getId()).name("");
final Update targetTypeUpdateEmpty = Update.builder().id(targetType.getId()).name("").build();
assertThatExceptionOfType(ConstraintViolationException.class)
.as("targetType with too short name should not be updated")
.isThrownBy(() -> targetTypeManagement.update(targetTypeUpdateEmpty));

13
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RsqlTargetFieldTest.java
View File

@@ -20,6 +20,7 @@ import java.util.Map;
import org.eclipse.hawkbit.repository.TargetFields;
import org.eclipse.hawkbit.repository.TargetTagManagement;
import org.eclipse.hawkbit.repository.TargetTypeFields;
import org.eclipse.hawkbit.repository.TargetTypeManagement;
import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
@@ -50,13 +51,13 @@ class RsqlTargetFieldTest extends AbstractJpaIntegrationTest {
@BeforeEach
void setupBeforeTest() {
targetType1 = targetTypeManagement
.create(entityFactory.targetType().create()
.name("Type1").description("Desc. Type1")
.key("Type1.key"));
.create(TargetTypeManagement.Create.builder()
.name("Type1").description("Desc. Type1").key("Type1.key")
.build());
targetType2 = targetTypeManagement
.create(entityFactory.targetType().create()
.name("Type2").description("Desc. Type2")
.key("Type2.key"));
.create(TargetTypeManagement.Create.builder()
.name("Type2").description("Desc. Type2").key("Type2.key")
.build());
final DistributionSet ds = testdataFactory.createDistributionSet("AssignedDs");