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

14
hawkbit-repository/hawkbit-repository-api/pom.xml
View File

@@ -58,4 +58,18 @@
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<configuration>
<doclint>syntax</doclint>
<!-- javadoc fail on TargetTypeManagement.Create because of lombok CreateBuildaer-->
<failOnError>false</failOnError>
</configuration>
</plugin>
</plugins>
</build>
</project>

2
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/DistributionSetTypeManagement.java
View File

@@ -92,10 +92,12 @@ public interface DistributionSetTypeManagement<T extends DistributionSetType>
@ToString(callSuper = true)
final class Create extends UpdateCreate {
@ValidString
@Size(min = 1, max = Type.KEY_MAX_SIZE)
@NotNull
private String key;
@ValidString
@Size(min = 1, max = NamedEntity.NAME_MAX_SIZE)
@NotNull
private String name;

6
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/EntityFactory.java
View File

@@ -14,7 +14,6 @@ import org.eclipse.hawkbit.repository.builder.RolloutBuilder;
import org.eclipse.hawkbit.repository.builder.RolloutGroupBuilder;
import org.eclipse.hawkbit.repository.builder.TargetBuilder;
import org.eclipse.hawkbit.repository.builder.TargetFilterQueryBuilder;
import org.eclipse.hawkbit.repository.builder.TargetTypeBuilder;
import org.eclipse.hawkbit.repository.model.BaseEntity;
/**
@@ -42,11 +41,6 @@ public interface EntityFactory {
*/
TargetBuilder target();
/**
* @return {@link TargetTypeBuilder} object
*/
TargetTypeBuilder targetType();
/**
* @return {@link TargetFilterQueryBuilder} object
*/

2
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/SoftwareModuleTypeManagement.java
View File

@@ -52,10 +52,12 @@ public interface SoftwareModuleTypeManagement<T extends SoftwareModuleType>
@ToString(callSuper = true)
final class Create extends UpdateCreate {
@ValidString
@Size(min = 1, max = Type.KEY_MAX_SIZE)
@NotNull
private String key;
@ValidString
@Size(min = 1, max = NamedEntity.NAME_MAX_SIZE)
@NotNull
private String name;

4
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/TargetTagManagement.java
View File

@@ -43,13 +43,13 @@ public interface TargetTagManagement<T extends TargetTag>
@Getter
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
final class Create extends DistributionSetTagManagement.UpdateCreate {}
final class Create extends UpdateCreate {}
@SuperBuilder
@Getter
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
final class Update extends DistributionSetTagManagement.UpdateCreate implements Identifiable<Long> {
final class Update extends UpdateCreate implements Identifiable<Long> {
@NotNull
private Long id;

145
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/TargetTypeManagement.java
View File

@@ -12,26 +12,29 @@ package org.eclipse.hawkbit.repository;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.BRACKET_CLOSE;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.BRACKET_OPEN;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.HAS_AUTH_AND;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.HAS_AUTH_CREATE_TARGET_TYPE;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.HAS_AUTH_DELETE_TARGET_TYPE;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.HAS_AUTH_PREFIX;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.HAS_AUTH_READ_TARGET_TYPE;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.HAS_AUTH_SUFFIX;
import static org.eclipse.hawkbit.im.authentication.SpringEvalExpressions.HAS_AUTH_UPDATE_TARGET_TYPE;
import java.util.Collection;
import java.util.List;
import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import jakarta.validation.Valid;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.ToString;
import lombok.experimental.SuperBuilder;
import org.eclipse.hawkbit.im.authentication.SpPermission;
import org.eclipse.hawkbit.repository.builder.TargetTypeCreate;
import org.eclipse.hawkbit.repository.builder.TargetTypeUpdate;
import org.eclipse.hawkbit.repository.exception.TargetTypeKeyOrNameRequiredException;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
import org.eclipse.hawkbit.repository.model.NamedEntity;
import org.eclipse.hawkbit.repository.model.TargetType;
import org.springframework.data.domain.Page;
import org.eclipse.hawkbit.repository.model.Type;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Slice;
import org.springframework.security.access.prepost.PreAuthorize;
@@ -39,7 +42,8 @@ import org.springframework.security.access.prepost.PreAuthorize;
/**
* Management service for {@link TargetType}s.
*/
public interface TargetTypeManagement {
public interface TargetTypeManagement<T extends TargetType>
extends RepositoryManagement<T, TargetTypeManagement.Create, TargetTypeManagement.Update> {
String HAS_AUTH_READ_DISTRIBUTION_SET_AND_UPDATE_TARGET_TYPE = BRACKET_OPEN +
HAS_AUTH_PREFIX + SpPermission.READ_DISTRIBUTION_SET + HAS_AUTH_SUFFIX +
@@ -47,6 +51,11 @@ public interface TargetTypeManagement {
HAS_AUTH_PREFIX + SpPermission.UPDATE_TARGET_TYPE + HAS_AUTH_SUFFIX +
BRACKET_CLOSE;
@Override
default String permissionGroup() {
return "TARGET_TYPE";
}
/**
* @param key as {@link TargetType#getKey()}
* @return {@link TargetType}
@@ -61,12 +70,6 @@ public interface TargetTypeManagement {
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
Optional<TargetType> getByName(@NotEmpty String name);
/**
* @return total count
*/
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
long count();
/**
* @param name as {@link TargetType#getName()}
* @return total count by name
@@ -74,41 +77,6 @@ public interface TargetTypeManagement {
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
long countByName(String name);
/**
* @param create TargetTypeCreate
* @return targetType
*/
@PreAuthorize(HAS_AUTH_CREATE_TARGET_TYPE)
TargetType create(@NotNull @Valid TargetTypeCreate create);
/**
* @param creates List of TargetTypeCreate
* @return List of targetType
*/
@PreAuthorize(HAS_AUTH_CREATE_TARGET_TYPE)
List<TargetType> create(@NotEmpty @Valid Collection<TargetTypeCreate> creates);
/**
* @param id targetTypeId
*/
@PreAuthorize(HAS_AUTH_DELETE_TARGET_TYPE)
void delete(@NotNull Long id);
/**
* @param pageable Page
* @return TargetType page
*/
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
Slice<TargetType> findAll(@NotNull Pageable pageable);
/**
* @param rsql query param
* @param pageable Page
* @return Target type
*/
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
Page<TargetType> findByRsql(@NotEmpty String rsql, @NotNull Pageable pageable);
/**
* Retrieves {@link TargetType}s by filtering on the given parameters.
*
@@ -119,27 +87,6 @@ public interface TargetTypeManagement {
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
Slice<TargetType> findByName(String name, @NotNull Pageable pageable);
/**
* @param id Target type ID
* @return Target Type
*/
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
Optional<TargetType> get(long id);
/**
* @param ids List of Target type ID
* @return Target type list
*/
@PreAuthorize(HAS_AUTH_READ_TARGET_TYPE)
List<TargetType> get(@NotEmpty Collection<Long> ids);
/**
* @param update TargetTypeUpdate
* @return Target Type
*/
@PreAuthorize(HAS_AUTH_UPDATE_TARGET_TYPE)
TargetType update(@NotNull @Valid TargetTypeUpdate update);
/**
* @param id Target type ID
* @param distributionSetTypeIds Distribution set ID
@@ -155,4 +102,60 @@ public interface TargetTypeManagement {
*/
@PreAuthorize(HAS_AUTH_READ_DISTRIBUTION_SET_AND_UPDATE_TARGET_TYPE)
TargetType unassignDistributionSetType(long id, long distributionSetTypeIds);
@SuperBuilder
@Getter
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
final class Create extends UpdateCreate {
@ValidString
@Size(min = 1, max = Type.KEY_MAX_SIZE)
@NotNull
private String key;
@ValidString
@Size(min = 1, max = NamedEntity.NAME_MAX_SIZE)
@NotNull
private String name;
private Set<DistributionSetType> distributionSetTypes;
private Create(final CreateBuilder<?, ?> builder) {
super(builder);
if (builder.key == null && builder.name == null) {
throw new TargetTypeKeyOrNameRequiredException("Key or name of the target type shall be specified!");
}
key = builder.key == null ? builder.name : builder.key;
name = builder.name == null ? builder.key : builder.name;
this.distributionSetTypes = builder.distributionSetTypes == null ? Collections.emptySet() : builder.distributionSetTypes;
}
}
@SuperBuilder
@Getter
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
final class Update extends UpdateCreate implements Identifiable<Long> {
@NotNull
private Long id;
@ValidString
@Size(min = 1, max = NamedEntity.NAME_MAX_SIZE)
private String name;
}
@SuperBuilder
@Getter
class UpdateCreate {
@ValidString
@Size(max = NamedEntity.DESCRIPTION_MAX_SIZE)
private String description;
@ValidString
@Size(max = Type.COLOUR_MAX_SIZE)
private String colour;
}
}

29
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/builder/TargetTypeBuilder.java
View File

@@ -1,29 +0,0 @@
/**
* Copyright (c) 2021 Bosch.IO GmbH and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.hawkbit.repository.builder;
import org.eclipse.hawkbit.repository.model.TargetType;
/**
* Builder for {@link TargetType}.
*/
public interface TargetTypeBuilder {
/**
* @param id of the updatable entity
* @return builder instance
*/
TargetTypeUpdate update(long id);
/**
* @return builder instance
*/
TargetTypeCreate create();
}

83
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/builder/TargetTypeCreate.java
View File

@@ -1,83 +0,0 @@
/**
* Copyright (c) 2021 Bosch.IO GmbH and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.hawkbit.repository.builder;
import java.util.Collection;
import java.util.Collections;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Size;
import org.eclipse.hawkbit.repository.model.BaseEntity;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
import org.eclipse.hawkbit.repository.model.NamedEntity;
import org.eclipse.hawkbit.repository.model.TargetType;
import org.eclipse.hawkbit.repository.model.Type;
/**
* Builder to create a new {@link TargetType} entry. Defines all fields
* that can be set at creation time. Other fields are set by the repository
* automatically, e.g. {@link BaseEntity#getCreatedAt()}.
*/
public interface TargetTypeCreate {
/**
* @param name for {@link TargetType#getName()}
* @return updated builder instance
*/
TargetTypeCreate name(@Size(min = 1, max = NamedEntity.NAME_MAX_SIZE) @NotEmpty String name);
/**
* @param description for {@link TargetType#getDescription()}
* @return updated builder instance
*/
TargetTypeCreate description(@Size(max = NamedEntity.DESCRIPTION_MAX_SIZE) String description);
/**
* @param key for {@link TargetType#getName()}
* @return updated builder instance
*/
TargetTypeCreate key(@Size(min = 1, max = Type.KEY_MAX_SIZE) @NotEmpty String key);
/**
* @param colour for {@link TargetType#getColour()}
* @return updated builder instance
*/
TargetTypeCreate colour(@Size(max = Type.COLOUR_MAX_SIZE) String colour);
/**
* @param compatible for {@link TargetType#getCompatibleDistributionSetTypes()}
* @return updated builder instance
*/
TargetTypeCreate compatible(@NotEmpty Collection<Long> compatible);
/**
* @param compatible for {@link TargetType#getCompatibleDistributionSetTypes()}
* @return updated builder instance
*/
default TargetTypeCreate compatible(@NotNull final Long compatible) {
return compatible(Collections.singletonList(compatible));
}
/**
* @param compatible for {@link TargetType#getCompatibleDistributionSetTypes()}
* @return updated builder instance
*/
default TargetTypeCreate compatible(@NotNull final DistributionSetType compatible) {
return compatible(compatible.getId());
}
/**
* @return peek on current state of {@link TargetType} in the
* builder
*/
TargetType build();
}

41
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/builder/TargetTypeUpdate.java
View File

@@ -1,41 +0,0 @@
/**
* Copyright (c) 2021 Bosch.IO GmbH and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.hawkbit.repository.builder;
import jakarta.validation.constraints.Size;
import org.eclipse.hawkbit.repository.model.NamedEntity;
import org.eclipse.hawkbit.repository.model.TargetType;
import org.eclipse.hawkbit.repository.model.Type;
/**
* Builder to update an existing {@link TargetType} entry. Defines all
* fields that can be updated.
*/
public interface TargetTypeUpdate {
/**
* @param description for {@link TargetType#getDescription()}
* @return updated builder instance
*/
TargetTypeUpdate description(@Size(max = NamedEntity.DESCRIPTION_MAX_SIZE) String description);
/**
* @param colour for {@link TargetType#getColour()}
* @return updated builder instance
*/
TargetTypeUpdate colour(@Size(max = Type.COLOUR_MAX_SIZE) String colour);
/**
* @param name Name
* @return updated builder instance
*/
TargetTypeUpdate name(@Size(max = NamedEntity.NAME_MAX_SIZE) String name);
}

17
hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/model/TargetType.java
View File

@@ -28,20 +28,11 @@ public interface TargetType extends Type {
}
/**
* Gets compatible distribution set types
*
* @return immutable set of optional {@link DistributionSetType}s
*/
Set<DistributionSetType> getCompatibleDistributionSetTypes();
/**
* Checks if the given {@link DistributionSetType} is in
* {@link #getCompatibleDistributionSetTypes()}.
*
* @param distributionSetTypeId search by {@link DistributionSetType#getId()}
* @return <code>true</code> if found
*/
default boolean containsCompatibleDistributionSetType(final Long distributionSetTypeId) {
return getCompatibleDistributionSetTypes().stream().anyMatch(element -> element.getId().equals(distributionSetTypeId));
}
Set<DistributionSetType> getDistributionSetTypes();
/**
* Unassigns a {@link DistributionSetType} from {@link TargetType}
@@ -49,5 +40,5 @@ public interface TargetType extends Type {
* @param dsTypeId that will be removed from {@link TargetType}
* @return the resulting target type
*/
TargetType removeDistributionSetType(final Long dsTypeId);
void removeDistributionSetType(final Long dsTypeId);
}

24
hawkbit-repository/hawkbit-repository-core/src/main/java/org/eclipse/hawkbit/repository/builder/GenericTargetTypeUpdate.java
View File

@@ -1,24 +0,0 @@
/**
* Copyright (c) 2021 Bosch.IO GmbH and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.hawkbit.repository.builder;
/**
* Update implementation.
*/
public class GenericTargetTypeUpdate extends AbstractTargetTypeUpdateCreate<TargetTypeUpdate>
implements TargetTypeUpdate {
/**
* @param id Target type ID
*/
public GenericTargetTypeUpdate(final Long id) {
super.id = id;
}
}

11
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/JpaEntityFactory.java
View File

@@ -15,7 +15,6 @@ import org.eclipse.hawkbit.repository.builder.RolloutBuilder;
import org.eclipse.hawkbit.repository.builder.RolloutGroupBuilder;
import org.eclipse.hawkbit.repository.builder.TargetBuilder;
import org.eclipse.hawkbit.repository.builder.TargetFilterQueryBuilder;
import org.eclipse.hawkbit.repository.builder.TargetTypeBuilder;
import org.eclipse.hawkbit.repository.jpa.builder.JpaActionStatusBuilder;
import org.eclipse.hawkbit.repository.jpa.builder.JpaRolloutGroupBuilder;
import org.springframework.validation.annotation.Validated;
@@ -27,17 +26,14 @@ import org.springframework.validation.annotation.Validated;
public class JpaEntityFactory implements EntityFactory {
private final TargetBuilder targetBuilder;
private final TargetTypeBuilder targetTypeBuilder;
private final TargetFilterQueryBuilder targetFilterQueryBuilder;
private final RolloutBuilder rolloutBuilder;
@SuppressWarnings("java:S107")
public JpaEntityFactory(
final TargetBuilder targetBuilder, final TargetTypeBuilder targetTypeBuilder,
final TargetFilterQueryBuilder targetFilterQueryBuilder,
final TargetBuilder targetBuilder, final TargetFilterQueryBuilder targetFilterQueryBuilder,
final RolloutBuilder rolloutBuilder) {
this.targetBuilder = targetBuilder;
this.targetTypeBuilder = targetTypeBuilder;
this.targetFilterQueryBuilder = targetFilterQueryBuilder;
this.rolloutBuilder = rolloutBuilder;
}
@@ -61,11 +57,6 @@ public class JpaEntityFactory implements EntityFactory {
return targetBuilder;
}
@Override
public TargetTypeBuilder targetType() {
return targetTypeBuilder;
}
@Override
public TargetFilterQueryBuilder targetFilterQuery() {
return targetFilterQueryBuilder;

16
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/JpaRepositoryConfiguration.java
View File

@@ -46,7 +46,6 @@ import org.eclipse.hawkbit.repository.autoassign.AutoAssignExecutor;
import org.eclipse.hawkbit.repository.builder.RolloutBuilder;
import org.eclipse.hawkbit.repository.builder.TargetBuilder;
import org.eclipse.hawkbit.repository.builder.TargetFilterQueryBuilder;
import org.eclipse.hawkbit.repository.builder.TargetTypeBuilder;
import org.eclipse.hawkbit.repository.event.ApplicationEventFilter;
import org.eclipse.hawkbit.repository.event.remote.EventEntityManager;
import org.eclipse.hawkbit.repository.event.remote.EventEntityManagerHolder;
@@ -61,7 +60,6 @@ import org.eclipse.hawkbit.repository.jpa.autocleanup.CleanupTask;
import org.eclipse.hawkbit.repository.jpa.builder.JpaRolloutBuilder;
import org.eclipse.hawkbit.repository.jpa.builder.JpaTargetBuilder;
import org.eclipse.hawkbit.repository.jpa.builder.JpaTargetFilterQueryBuilder;
import org.eclipse.hawkbit.repository.jpa.builder.JpaTargetTypeBuilder;
import org.eclipse.hawkbit.repository.jpa.cluster.DistributedLockRepository;
import org.eclipse.hawkbit.repository.jpa.cluster.LockProperties;
import org.eclipse.hawkbit.repository.jpa.event.JpaEventEntityManager;
@@ -311,15 +309,6 @@ public class JpaRepositoryConfiguration {
return new JpaTargetBuilder(targetTypeManagement);
}
/**
* @param dsTypeManagement for loading {@link TargetType#getCompatibleDistributionSetTypes()}
* @return TargetTypeBuilder bean
*/
@Bean
TargetTypeBuilder targetTypeBuilder(final DistributionSetTypeManagement<? extends DistributionSetType> dsTypeManagement) {
return new JpaTargetTypeBuilder(dsTypeManagement);
}
/**
* @param distributionSetManagement for loading {@link Rollout#getDistributionSet()}
* @return RolloutBuilder bean
@@ -450,10 +439,9 @@ public class JpaRepositoryConfiguration {
@Bean
@ConditionalOnMissingBean
EntityFactory entityFactory(
final TargetBuilder targetBuilder, final TargetTypeBuilder targetTypeBuilder,
final TargetFilterQueryBuilder targetFilterQueryBuilder,
final TargetBuilder targetBuilder, final TargetFilterQueryBuilder targetFilterQueryBuilder,
final RolloutBuilder rolloutBuilder) {
return new JpaEntityFactory(targetBuilder, targetTypeBuilder, targetFilterQueryBuilder, rolloutBuilder);
return new JpaEntityFactory(targetBuilder, targetFilterQueryBuilder, rolloutBuilder);
}
/**

4
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/builder/JpaTargetCreate.java
View File

@@ -23,9 +23,9 @@ import org.springframework.util.ObjectUtils;
*/
public class JpaTargetCreate extends AbstractTargetUpdateCreate<TargetCreate> implements TargetCreate {
private final TargetTypeManagement targetTypeManagement;
private final TargetTypeManagement<? extends TargetType> targetTypeManagement;
JpaTargetCreate(final TargetTypeManagement targetTypeManagement) {
JpaTargetCreate(final TargetTypeManagement<? extends TargetType> targetTypeManagement) {
super(null);
this.targetTypeManagement = targetTypeManagement;
}

40
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/builder/JpaTargetTypeBuilder.java
View File

@@ -1,40 +0,0 @@
/**
* Copyright (c) 2021 Bosch.IO GmbH and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.hawkbit.repository.jpa.builder;
import org.eclipse.hawkbit.repository.DistributionSetTypeManagement;
import org.eclipse.hawkbit.repository.builder.GenericTargetTypeUpdate;
import org.eclipse.hawkbit.repository.builder.TargetTypeBuilder;
import org.eclipse.hawkbit.repository.builder.TargetTypeCreate;
import org.eclipse.hawkbit.repository.builder.TargetTypeUpdate;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
import org.eclipse.hawkbit.repository.model.TargetType;
/**
* Builder implementation for {@link TargetType}.
*/
public class JpaTargetTypeBuilder implements TargetTypeBuilder {
private final DistributionSetTypeManagement<? extends DistributionSetType> distributionSetTypeManagement;
public JpaTargetTypeBuilder(DistributionSetTypeManagement<? extends DistributionSetType> distributionSetTypeManagement) {
this.distributionSetTypeManagement = distributionSetTypeManagement;
}
@Override
public TargetTypeUpdate update(long id) {
return new GenericTargetTypeUpdate(id);
}
@Override
public TargetTypeCreate create() {
return new JpaTargetTypeCreate(distributionSetTypeManagement);
}
}

60
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/builder/JpaTargetTypeCreate.java
View File

@@ -1,60 +0,0 @@
/**
* Copyright (c) 2021 Bosch.IO GmbH and others
*
* This program and the accompanying materials are made
* available under the terms of the Eclipse Public License 2.0
* which is available at https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*/
package org.eclipse.hawkbit.repository.jpa.builder;
import java.util.Collection;
import java.util.Collections;
import org.eclipse.hawkbit.repository.DistributionSetTypeManagement;
import org.eclipse.hawkbit.repository.builder.AbstractTargetTypeUpdateCreate;
import org.eclipse.hawkbit.repository.builder.TargetTypeCreate;
import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
import org.eclipse.hawkbit.repository.exception.TargetTypeKeyOrNameRequiredException;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetType;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
import org.springframework.util.CollectionUtils;
/**
* Create/build implementation.
*/
public class JpaTargetTypeCreate extends AbstractTargetTypeUpdateCreate<TargetTypeCreate> implements TargetTypeCreate {
private final DistributionSetTypeManagement<? extends DistributionSetType> distributionSetTypeManagement;
JpaTargetTypeCreate(final DistributionSetTypeManagement<? extends DistributionSetType> distributionSetTypeManagement) {
this.distributionSetTypeManagement = distributionSetTypeManagement;
}
@Override
public JpaTargetType build() {
if (key == null && name == null) {
throw new TargetTypeKeyOrNameRequiredException("Key or name of the target type shall be specified!");
}
final JpaTargetType result = new JpaTargetType(key == null ? name : key, name == null ? key : name, description, colour);
findDistributionSetTypeWithExceptionIfNotFound(compatible).forEach(result::addCompatibleDistributionSetType);
return result;
}
private Collection<? extends DistributionSetType> findDistributionSetTypeWithExceptionIfNotFound(
final Collection<Long> distributionSetTypeId) {
if (CollectionUtils.isEmpty(distributionSetTypeId)) {
return Collections.emptyList();
}
final Collection<? extends DistributionSetType> type = distributionSetTypeManagement.get(distributionSetTypeId);
if (type.size() < distributionSetTypeId.size()) {
throw new EntityNotFoundException(SoftwareModuleType.class, distributionSetTypeId);
}
return type;
}
}

2
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaDeploymentManagement.java
View File

@@ -719,7 +719,7 @@ public class JpaDeploymentManagement extends JpaActionManagement implements Depl
final Set<DistributionSetType> incompatibleDistSetTypes = distributionSetManagement.get(distSetIds).stream()
.map(DistributionSet::getType)
.collect(Collectors.toSet());
incompatibleDistSetTypes.removeAll(target.getTargetType().getCompatibleDistributionSetTypes());
incompatibleDistSetTypes.removeAll(target.getTargetType().getDistributionSetTypes());
if (!incompatibleDistSetTypes.isEmpty()) {
final Set<String> distSetTypeNames = incompatibleDistSetTypes.stream()

132
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/management/JpaTargetTypeManagement.java
View File

@@ -10,37 +10,31 @@
package org.eclipse.hawkbit.repository.jpa.management;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.function.ToLongFunction;
import jakarta.persistence.EntityManager;
import org.eclipse.hawkbit.repository.QuotaManagement;
import org.eclipse.hawkbit.repository.TargetTypeFields;
import org.eclipse.hawkbit.repository.TargetTypeManagement;
import org.eclipse.hawkbit.repository.builder.GenericTargetTypeUpdate;
import org.eclipse.hawkbit.repository.builder.TargetTypeCreate;
import org.eclipse.hawkbit.repository.builder.TargetTypeUpdate;
import org.eclipse.hawkbit.repository.exception.AssignmentQuotaExceededException;
import org.eclipse.hawkbit.repository.exception.EntityNotFoundException;
import org.eclipse.hawkbit.repository.exception.TargetTypeInUseException;
import org.eclipse.hawkbit.repository.jpa.JpaManagementHelper;
import org.eclipse.hawkbit.repository.jpa.acm.AccessController;
import org.eclipse.hawkbit.repository.jpa.builder.JpaTargetTypeCreate;
import org.eclipse.hawkbit.repository.jpa.configuration.Constants;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetType;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetType;
import org.eclipse.hawkbit.repository.jpa.repository.DistributionSetTypeRepository;
import org.eclipse.hawkbit.repository.jpa.repository.TargetRepository;
import org.eclipse.hawkbit.repository.jpa.repository.TargetTypeRepository;
import org.eclipse.hawkbit.repository.jpa.rsql.RsqlUtility;
import org.eclipse.hawkbit.repository.jpa.specifications.TargetTypeSpecification;
import org.eclipse.hawkbit.repository.jpa.utils.QuotaHelper;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
import org.eclipse.hawkbit.repository.model.TargetType;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBooleanProperty;
import org.springframework.dao.ConcurrencyFailureException;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Slice;
import org.springframework.retry.annotation.Backoff;
@@ -56,119 +50,53 @@ import org.springframework.validation.annotation.Validated;
@Validated
@Service
@ConditionalOnBooleanProperty(prefix = "hawkbit.jpa", name = { "enabled", "target-type-management" }, matchIfMissing = true)
public class JpaTargetTypeManagement implements TargetTypeManagement {
public class JpaTargetTypeManagement
extends AbstractJpaRepositoryManagement<JpaTargetType, TargetTypeManagement.Create, TargetTypeManagement.Update, TargetTypeRepository, TargetTypeFields>
implements TargetTypeManagement<JpaTargetType>{
private final TargetTypeRepository targetTypeRepository;
private final TargetRepository targetRepository;
private final DistributionSetTypeRepository distributionSetTypeRepository;
private final QuotaManagement quotaManagement;
protected JpaTargetTypeManagement(final TargetTypeRepository targetTypeRepository,
final TargetRepository targetRepository, final DistributionSetTypeRepository distributionSetTypeRepository,
final QuotaManagement quotaManagement) {
this.targetTypeRepository = targetTypeRepository;
protected JpaTargetTypeManagement(
final TargetTypeRepository targetTypeRepository, final EntityManager entityManager,
final TargetRepository targetRepository,
final DistributionSetTypeRepository distributionSetTypeRepository, final QuotaManagement quotaManagement) {
super(targetTypeRepository, entityManager);
this.targetRepository = targetRepository;
this.distributionSetTypeRepository = distributionSetTypeRepository;
this.quotaManagement = quotaManagement;
}
@Override
protected void delete0(final Collection<Long> ids) {
for (final Long id : ids) {
if (targetRepository.countByTargetTypeId(id) > 0) {
throw new TargetTypeInUseException("Cannot delete target type that is in use: " + id);
}
}
super.delete0(ids);
}
@Override
public Optional<TargetType> getByKey(final String key) {
return targetTypeRepository.findOne(TargetTypeSpecification.hasKey(key)).map(TargetType.class::cast);
return jpaRepository.findOne(TargetTypeSpecification.hasKey(key)).map(TargetType.class::cast);
}
@Override
public Optional<TargetType> getByName(final String name) {
return targetTypeRepository.findOne(TargetTypeSpecification.hasName(name)).map(TargetType.class::cast);
}
@Override
public long count() {
return targetTypeRepository.count();
}
@Override
public long countByName(final String name) {
return targetTypeRepository.count(TargetTypeSpecification.hasName(name));
}
@Override
@Transactional
@Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
backoff = @Backoff(delay = Constants.TX_RT_DELAY))
public TargetType create(final TargetTypeCreate create) {
final JpaTargetType typeCreate = ((JpaTargetTypeCreate) create).build();
return targetTypeRepository.save(AccessController.Operation.CREATE, typeCreate);
}
@Override
@Transactional
@Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
backoff = @Backoff(delay = Constants.TX_RT_DELAY))
public List<TargetType> create(final Collection<TargetTypeCreate> creates) {
final List<JpaTargetType> typeCreate =
creates.stream().map(create -> ((JpaTargetTypeCreate) create).build()).toList();
return Collections.unmodifiableList(targetTypeRepository.saveAll(AccessController.Operation.CREATE, typeCreate));
}
@Override
@Transactional
@Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
backoff = @Backoff(delay = Constants.TX_RT_DELAY))
public void delete(final Long id) {
getByIdAndThrowIfNotFound(id);
if (targetRepository.countByTargetTypeId(id) > 0) {
throw new TargetTypeInUseException("Cannot delete target type that is in use");
}
targetTypeRepository.deleteById(id);
}
@Override
public Slice<TargetType> findAll(final Pageable pageable) {
return targetTypeRepository.findAllWithoutCount(pageable).map(TargetType.class::cast);
}
@Override
public Page<TargetType> findByRsql(final String rsql, final Pageable pageable) {
return JpaManagementHelper.findAllWithCountBySpec(
targetTypeRepository,
List.of(RsqlUtility.getInstance().buildRsqlSpecification(rsql, TargetTypeFields.class)),
pageable);
return jpaRepository.findOne(TargetTypeSpecification.hasName(name)).map(TargetType.class::cast);
}
@Override
public Slice<TargetType> findByName(final String name, final Pageable pageable) {
return JpaManagementHelper.findAllWithoutCountBySpec(targetTypeRepository, List.of(TargetTypeSpecification.likeName(name)), pageable
);
return JpaManagementHelper.findAllWithoutCountBySpec(jpaRepository, List.of(TargetTypeSpecification.likeName(name)), pageable);
}
@Override
public Optional<TargetType> get(final long id) {
return targetTypeRepository.findById(id).map(TargetType.class::cast);
}
@Override
public List<TargetType> get(final Collection<Long> ids) {
return Collections.unmodifiableList(targetTypeRepository.findAllById(ids));
}
@Override
@Transactional
@Retryable(retryFor = { ConcurrencyFailureException.class }, maxAttempts = Constants.TX_RT_MAX,
backoff = @Backoff(delay = Constants.TX_RT_DELAY))
public TargetType update(final TargetTypeUpdate update) {
final GenericTargetTypeUpdate typeUpdate = (GenericTargetTypeUpdate) update;
final JpaTargetType type = getByIdAndThrowIfNotFound(typeUpdate.getId());
typeUpdate.getName().ifPresent((type::setName));
typeUpdate.getDescription().ifPresent(type::setDescription);
typeUpdate.getColour().ifPresent(type::setColour);
return targetTypeRepository.save(type);
public long countByName(final String name) {
return jpaRepository.count(TargetTypeSpecification.hasName(name));
}
@Override
@@ -186,10 +114,10 @@ public class JpaTargetTypeManagement implements TargetTypeManagement {
}
final JpaTargetType type = getByIdAndThrowIfNotFound(id);
assertDistributionSetTypeQuota(id, distributionSetTypeIds.size(), typeId -> type.getCompatibleDistributionSetTypes().size());
assertDistributionSetTypeQuota(id, distributionSetTypeIds.size(), typeId -> type.getDistributionSetTypes().size());
dsTypes.forEach(type::addCompatibleDistributionSetType);
return targetTypeRepository.save(type);
return jpaRepository.save(type);
}
@Override
@@ -202,7 +130,7 @@ public class JpaTargetTypeManagement implements TargetTypeManagement {
type.removeDistributionSetType(distributionSetTypeId);
return targetTypeRepository.save(type);
return jpaRepository.save(type);
}
@SuppressWarnings("java:S2201") // the idea is just to check for distribution set type existence
@@ -213,7 +141,7 @@ public class JpaTargetTypeManagement implements TargetTypeManagement {
}
private JpaTargetType getByIdAndThrowIfNotFound(final Long id) {
return targetTypeRepository
return jpaRepository
.findById(id)
.orElseThrow(() -> new EntityNotFoundException(TargetType.class, id));
}

5
hawkbit-repository/hawkbit-repository-jpa/src/main/java/org/eclipse/hawkbit/repository/jpa/model/JpaTargetType.java
View File

@@ -78,7 +78,7 @@ public class JpaTargetType extends AbstractJpaTypeEntity implements TargetType,
}
@Override
public Set<DistributionSetType> getCompatibleDistributionSetTypes() {
public Set<DistributionSetType> getDistributionSetTypes() {
return Collections.unmodifiableSet(distributionSetTypes);
}
@@ -88,12 +88,11 @@ public class JpaTargetType extends AbstractJpaTypeEntity implements TargetType,
* @param dsTypeId Distribution set type ID
* @return Target type
*/
public JpaTargetType removeDistributionSetType(final Long dsTypeId) {
public void removeDistributionSetType(final Long dsTypeId) {
distributionSetTypes.stream()
.filter(element -> element.getId().equals(dsTypeId))
.findAny()
.ifPresent(distributionSetTypes::remove);
return this;
}
@Override

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

3
hawkbit-repository/hawkbit-repository-test/src/main/java/org/eclipse/hawkbit/repository/test/util/AbstractIntegrationTest.java
View File

@@ -67,6 +67,7 @@ import org.eclipse.hawkbit.repository.model.SoftwareModule;
import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.TargetTag;
import org.eclipse.hawkbit.repository.model.TargetType;
import org.eclipse.hawkbit.repository.test.TestConfiguration;
import org.eclipse.hawkbit.repository.test.matcher.EventVerifier;
import org.eclipse.hawkbit.security.SystemSecurityContext;
@@ -141,7 +142,7 @@ public abstract class AbstractIntegrationTest {
@Autowired
protected TargetManagement targetManagement;
@Autowired
protected TargetTypeManagement targetTypeManagement;
protected TargetTypeManagement<? extends TargetType> targetTypeManagement;
@Autowired
protected TargetFilterQueryManagement targetFilterQueryManagement;
@Autowired

34
hawkbit-repository/hawkbit-repository-test/src/main/java/org/eclipse/hawkbit/repository/test/util/TestdataFactory.java
View File

@@ -50,7 +50,6 @@ import org.eclipse.hawkbit.repository.TargetTagManagement;
import org.eclipse.hawkbit.repository.TargetTypeManagement;
import org.eclipse.hawkbit.repository.builder.DynamicRolloutGroupTemplate;
import org.eclipse.hawkbit.repository.builder.TargetCreate;
import org.eclipse.hawkbit.repository.builder.TargetTypeCreate;
import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.Action.ActionType;
import org.eclipse.hawkbit.repository.model.Action.Status;
@@ -75,7 +74,6 @@ import org.eclipse.hawkbit.repository.model.RolloutGroupConditions;
import org.eclipse.hawkbit.repository.model.SoftwareModule;
import org.eclipse.hawkbit.repository.model.SoftwareModule.MetadataValueCreate;
import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
import org.eclipse.hawkbit.repository.model.Tag;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.TargetFilterQuery;
import org.eclipse.hawkbit.repository.model.TargetTag;
@@ -157,8 +155,8 @@ public class TestdataFactory {
private final DistributionSetInvalidationManagement distributionSetInvalidationManagement;
private final TargetManagement targetManagement;
private final TargetFilterQueryManagement targetFilterQueryManagement;
private final TargetTypeManagement targetTypeManagement;
private final TargetTagManagement targetTagManagement;
private final TargetTypeManagement<? extends TargetType> targetTypeManagement;
private final TargetTagManagement<? extends TargetTag> targetTagManagement;
private final DeploymentManagement deploymentManagement;
private final RolloutManagement rolloutManagement;
private final RolloutHandler rolloutHandler;
@@ -175,7 +173,8 @@ public class TestdataFactory {
final DistributionSetTagManagement<? extends DistributionSetTag> distributionSetTagManagement,
final DistributionSetInvalidationManagement distributionSetInvalidationManagement,
final TargetManagement targetManagement, final TargetFilterQueryManagement targetFilterQueryManagement,
final TargetTypeManagement targetTypeManagement, final TargetTagManagement targetTagManagement,
final TargetTypeManagement<? extends TargetType> targetTypeManagement,
final TargetTagManagement<? extends TargetTag> targetTagManagement,
final DeploymentManagement deploymentManagement,
final RolloutManagement rolloutManagement, final RolloutHandler rolloutHandler,
final QuotaManagement quotaManagement,
@@ -912,7 +911,7 @@ public class TestdataFactory {
* @param tagPrefix prefix for the {@link TargetTag#getName()}
* @return the created set of {@link TargetTag}s
*/
public List<TargetTag> createTargetTags(final int number, final String tagPrefix) {
public List<? extends TargetTag> createTargetTags(final int number, final String tagPrefix) {
final List<TargetTagManagement.Create> result = new ArrayList<>(number);
for (int i = 0; i < number; i++) {
result.add(TargetTagManagement.Create.builder().name(tagPrefix + i).description(tagPrefix + i).colour(String.valueOf(i)).build());
@@ -1184,9 +1183,10 @@ public class TestdataFactory {
*/
public TargetType findOrCreateTargetType(final String targetTypeName) {
return targetTypeManagement.getByName(targetTypeName)
.orElseGet(() -> targetTypeManagement.create(entityFactory.targetType().create()
.orElseGet(() -> targetTypeManagement.create(TargetTypeManagement.Create.builder()
.name(targetTypeName).description(targetTypeName + SPACE_AND_DESCRIPTION)
.key(targetTypeName + " key").colour(DEFAULT_COLOUR)));
.key(targetTypeName + " key").colour(DEFAULT_COLOUR)
.build()));
}
/**
@@ -1196,10 +1196,11 @@ public class TestdataFactory {
* @param targetTypeName {@link TargetType#getName()}
* @return persisted {@link TargetType}
*/
public TargetType createTargetType(final String targetTypeName, final List<DistributionSetType> compatibleDsTypes) {
return targetTypeManagement.create(entityFactory.targetType().create().name(targetTypeName)
.description(targetTypeName + SPACE_AND_DESCRIPTION).colour(DEFAULT_COLOUR)
.compatible(compatibleDsTypes.stream().map(DistributionSetType::getId).toList()));
public TargetType createTargetType(final String targetTypeName, final Set<DistributionSetType> compatibleDsTypes) {
return targetTypeManagement.create(TargetTypeManagement.Create.builder()
.name(targetTypeName).description(targetTypeName + SPACE_AND_DESCRIPTION).colour(DEFAULT_COLOUR)
.distributionSetTypes(compatibleDsTypes)
.build());
}
/**
@@ -1208,12 +1209,13 @@ public class TestdataFactory {
* @param targetTypePrefix {@link TargetType#getName()}
* @return persisted {@link TargetType}
*/
public List<TargetType> createTargetTypes(final String targetTypePrefix, final int count) {
final List<TargetTypeCreate> result = new ArrayList<>(count);
public List<? extends TargetType> createTargetTypes(final String targetTypePrefix, final int count) {
final List<TargetTypeManagement.Create> result = new ArrayList<>(count);
for (int i = 0; i < count; i++) {
result.add(entityFactory.targetType().create()
result.add(TargetTypeManagement.Create.builder()
.name(targetTypePrefix + i).description(targetTypePrefix + SPACE_AND_DESCRIPTION)
.key(targetTypePrefix + i + " key").colour(DEFAULT_COLOUR));
.key(targetTypePrefix + i + " key").colour(DEFAULT_COLOUR)
.build());
}
return targetTypeManagement.create(result);
}