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

Merge remote-tracking branch 'eclipse/master' into cleanup-properties

Browse Source
This commit is contained in:
Kai Zimmermann
2016-02-25 18:01:56 +01:00
parent ab18e12b69 07bf7e65bb
commit 3eaab83014
77 changed files with 426 additions and 2723 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
hawkbit-repository/src/main/java/org/eclipse/hawkbit/report/model/ListReportSeries.java
View File

@@ -21,7 +21,7 @@ import java.util.List;
*/
public class ListReportSeries extends AbstractReportSeries {
private final List<Number> data = new ArrayList<Number>();
private final List<Number> data = new ArrayList<>();
/**
* @param name

7
hawkbit-repository/src/main/java/org/eclipse/hawkbit/repository/DeploymentManagement.java
View File

@@ -330,7 +330,7 @@ public class DeploymentManagement {
// one we have been switched to canceling state because for targets
// which we have changed to
// canceling we don't want to publish the new action update event.
final Set<Long> targetIdsCancellList = new HashSet<Long>();
final Set<Long> targetIdsCancellList = new HashSet<>();
targetIds.forEach(ids -> targetIdsCancellList.addAll(overrideObsoleteUpdateActions(ids)));
// cancel all scheduled actions which are in-active, these actions were
@@ -435,7 +435,7 @@ public class DeploymentManagement {
*/
private Set<Long> overrideObsoleteUpdateActions(final List<Long> targetsIds) {
final Set<Long> cancelledTargetIds = new HashSet<Long>();
final Set<Long> cancelledTargetIds = new HashSet<>();
// Figure out if there are potential target/action combinations that
// need to be considered
@@ -779,8 +779,7 @@ public class DeploymentManagement {
multiselect.where(cb.equal(actionRoot.get(Action_.target), target));
multiselect.orderBy(cb.desc(actionRoot.get(Action_.id)));
multiselect.groupBy(actionRoot.get(Action_.id));
final List<ActionWithStatusCount> resultList = entityManager.createQuery(multiselect).getResultList();
return resultList;
return entityManager.createQuery(multiselect).getResultList();
}
/**

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

@@ -57,7 +57,7 @@ public class NoCountPagingRepository {
*/
public <T, I extends Serializable> Slice<T> findAll(final Specification<T> spec, final Pageable pageable,
final Class<T> domainClass) {
final SimpleJpaNoCountRepository<T, I> noCountDao = new SimpleJpaNoCountRepository<T, I>(domainClass, em);
final SimpleJpaNoCountRepository<T, I> noCountDao = new SimpleJpaNoCountRepository<>(domainClass, em);
return noCountDao.findAll(spec, pageable);
}
@@ -76,7 +76,7 @@ public class NoCountPagingRepository {
* org.springframework.data.domain.Pageable)
*/
public <T, I extends Serializable> Slice<T> findAll(final Pageable pageable, final Class<T> domainClass) {
final SimpleJpaNoCountRepository<T, I> noCountDao = new SimpleJpaNoCountRepository<T, I>(domainClass, em);
final SimpleJpaNoCountRepository<T, I> noCountDao = new SimpleJpaNoCountRepository<>(domainClass, em);
return noCountDao.findAll(pageable);
}
@@ -120,7 +120,7 @@ public class NoCountPagingRepository {
final List<T> content = query.getResultList();
return new PageImpl<T>(content, pageable, content.size());
return new PageImpl<>(content, pageable, content.size());
}
}
}

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

@@ -160,7 +160,7 @@ public class TagManagement {
public void deleteTargetTag(@NotEmpty final String targetTagName) {
final TargetTag tag = targetTagRepository.findByNameEquals(targetTagName);
final List<Target> changed = new LinkedList<Target>();
final List<Target> changed = new LinkedList<>();
for (final Target target : targetRepository.findByTag(tag)) {
target.getTags().remove(tag);
changed.add(target);
@@ -311,7 +311,7 @@ public class TagManagement {
public void deleteDistributionSetTag(@NotEmpty final String tagName) {
final DistributionSetTag tag = distributionSetTagRepository.findByNameEquals(tagName);
final List<DistributionSet> changed = new LinkedList<DistributionSet>();
final List<DistributionSet> changed = new LinkedList<>();
for (final DistributionSet set : distributionSetRepository.findByTag(tag)) {
set.getTags().remove(tag);
changed.add(set);

2
hawkbit-repository/src/main/java/org/eclipse/hawkbit/repository/model/ActionStatus.java
View File

@@ -63,7 +63,7 @@ public class ActionStatus extends BaseEntity {
@CollectionTable(name = "sp_action_status_messages", joinColumns = @JoinColumn(name = "action_status_id", foreignKey = @ForeignKey(value = ConstraintMode.CONSTRAINT, name = "fk_stat_msg_act_stat") ) , indexes = {
@Index(name = "sp_idx_action_status_msgs_01", columnList = "action_status_id") })
@Column(name = "detail_message", length = 512)
private final List<String> messages = new ArrayList<String>();
private final List<String> messages = new ArrayList<>();
/**
* Creates a new {@link ActionStatus} object.

2
hawkbit-repository/src/main/java/org/eclipse/hawkbit/repository/model/Target.java
View File

@@ -87,7 +87,7 @@ public class Target extends NamedEntity implements Persistable<Long> {
@JoinTable(name = "sp_target_target_tag", joinColumns = {
@JoinColumn(name = "target", foreignKey = @ForeignKey(value = ConstraintMode.CONSTRAINT, name = "fk_targ_targtag_target") ) }, inverseJoinColumns = {
@JoinColumn(name = "tag", foreignKey = @ForeignKey(value = ConstraintMode.CONSTRAINT, name = "fk_targ_targtag_tag") ) })
private Set<TargetTag> tags = new HashSet<TargetTag>();
private Set<TargetTag> tags = new HashSet<>();
@CascadeOnDelete
@OneToMany(fetch = FetchType.LAZY, orphanRemoval = true, cascade = { CascadeType.REMOVE })

2
hawkbit-repository/src/test/java/org/eclipse/hawkbit/MethodSecurityUtil.java
View File

@@ -54,7 +54,7 @@ public class MethodSecurityUtil {
if (!METHOD_SECURITY_EXCLUSION.contains(method.getName()) && !method.isSynthetic()
&& Modifier.isPublic(method.getModifiers())) {
final PreAuthorize annotation = method.getAnnotation(PreAuthorize.class);
assertThat(annotation).describedAs(
assertThat(annotation).as(
"The public method " + method.getName() + " is not annoated with @PreAuthorize, security leak?")
.isNotNull();
}

314
hawkbit-repository/src/test/java/org/eclipse/hawkbit/repository/DeploymentManagementTest.java
View File

@@ -19,7 +19,6 @@ import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import org.eclipse.hawkbit.AbstractIntegrationTest;
import org.eclipse.hawkbit.Constants;
@@ -98,8 +97,9 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final List<ActionWithStatusCount> findActionsWithStatusCountByTarget = deploymentManagement
.findActionsWithStatusCountByTargetOrderByIdDesc(testTarget.get(0));
assertThat(findActionsWithStatusCountByTarget).hasSize(1);
assertThat(findActionsWithStatusCountByTarget.get(0).getActionStatusCount()).isEqualTo(3L);
assertThat(findActionsWithStatusCountByTarget).as("wrong action size").hasSize(1);
assertThat(findActionsWithStatusCountByTarget.get(0).getActionStatusCount()).as("wrong action status size")
.isEqualTo(3L);
}
@Test
@@ -115,27 +115,32 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final DistributionSetTag tag = tagManagement.createDistributionSetTag(new DistributionSetTag("Tag1"));
final List<DistributionSet> assignedDS = distributionSetManagement.assignTag(assignDS, tag);
assertThat(assignedDS.size()).isEqualTo(4);
assignedDS.forEach(ds -> assertThat(ds.getTags().size()).isEqualTo(1));
assertThat(assignedDS.size()).as("assigned ds has wrong size").isEqualTo(4);
assignedDS.forEach(ds -> assertThat(ds.getTags().size()).as("ds has wrong tag size").isEqualTo(1));
DistributionSetTag findDistributionSetTag = tagManagement.findDistributionSetTag("Tag1");
assertThat(assignedDS.size()).isEqualTo(findDistributionSetTag.getAssignedToDistributionSet().size());
assertThat(assignedDS.size()).as("assigned ds has wrong size")
.isEqualTo(findDistributionSetTag.getAssignedToDistributionSet().size());
assertThat(distributionSetManagement.unAssignTag(Long.valueOf(100), findDistributionSetTag)).isNull();
assertThat(distributionSetManagement.unAssignTag(Long.valueOf(100), findDistributionSetTag))
.as("unassign tag result should be null").isNull();
final DistributionSet unAssignDS = distributionSetManagement.unAssignTag(assignDS.get(0),
findDistributionSetTag);
assertThat(unAssignDS.getId()).isEqualTo(assignDS.get(0));
assertThat(unAssignDS.getTags().size()).isEqualTo(0);
assertThat(unAssignDS.getId()).as("unassigned ds is wrong").isEqualTo(assignDS.get(0));
assertThat(unAssignDS.getTags().size()).as("unassigned ds has wrong tag size").isEqualTo(0);
findDistributionSetTag = tagManagement.findDistributionSetTag("Tag1");
assertThat(findDistributionSetTag.getAssignedToDistributionSet().size()).isEqualTo(3);
assertThat(findDistributionSetTag.getAssignedToDistributionSet().size()).as("ds tag ds has wrong ds size")
.isEqualTo(3);
final List<DistributionSet> unAssignTargets = distributionSetManagement
.unAssignAllDistributionSetsByTag(findDistributionSetTag);
findDistributionSetTag = tagManagement.findDistributionSetTag("Tag1");
assertThat(findDistributionSetTag.getAssignedToDistributionSet().size()).isEqualTo(0);
assertThat(unAssignTargets.size()).isEqualTo(3);
unAssignTargets.forEach(target -> assertThat(target.getTags().size()).isEqualTo(0));
assertThat(findDistributionSetTag.getAssignedToDistributionSet().size()).as("ds tag has wrong ds size")
.isEqualTo(0);
assertThat(unAssignTargets.size()).as("unassigned target has wrong size").isEqualTo(3);
unAssignTargets
.forEach(target -> assertThat(target.getTags().size()).as("target has wrong tag size").isEqualTo(0));
}
@Test
@@ -157,7 +162,8 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
targetManagement.findAllTargetIds().forEach(targetIdName -> {
assertThat(deploymentManagement.findActiveActionsByTarget(
targetManagement.findTargetByControllerID(targetIdName.getControllerId()))).hasSize(2);
targetManagement.findTargetByControllerID(targetIdName.getControllerId())))
.as("active action has wrong size").hasSize(2);
});
}
@@ -180,14 +186,14 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// check initial status
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.UNKNOWN);
.as("target has update status").isEqualTo(TargetUpdateStatus.UNKNOWN);
// assign the two sets in a row
Action firstAction = assignSet(target, dsFirst);
Action secondAction = assignSet(target, dsSecond);
assertThat(actionRepository.findAll()).hasSize(2);
assertThat(actionStatusRepository.findAll()).hasSize(2);
assertThat(actionRepository.findAll()).as("wrong size of actions").hasSize(2);
assertThat(actionStatusRepository.findAll()).as("wrong size of action status").hasSize(2);
// we cancel second -> back to first
deploymentManagement.cancelAction(secondAction,
@@ -197,10 +203,11 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
secondAction.setStatus(Status.CANCELED);
controllerManagement.addCancelActionStatus(
new ActionStatus(secondAction, Status.CANCELED, System.currentTimeMillis()), secondAction);
assertThat(actionStatusRepository.findAll()).hasSize(4);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet()).isEqualTo(dsFirst);
assertThat(actionStatusRepository.findAll()).as("wrong size of actions status").hasSize(4);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet()).as("wrong ds")
.isEqualTo(dsFirst);
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.PENDING);
.as("wrong update status").isEqualTo(TargetUpdateStatus.PENDING);
// we cancel first -> back to installed
deploymentManagement.cancelAction(firstAction,
@@ -210,11 +217,11 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
firstAction.setStatus(Status.CANCELED);
controllerManagement.addCancelActionStatus(
new ActionStatus(firstAction, Status.CANCELED, System.currentTimeMillis()), firstAction);
assertThat(actionStatusRepository.findAll()).hasSize(6);
assertThat(actionStatusRepository.findAll()).as("wrong size of action status").hasSize(6);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet())
.isEqualTo(dsInstalled);
.as("wrong assigned ds").isEqualTo(dsInstalled);
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.IN_SYNC);
.as("wrong update status").isEqualTo(TargetUpdateStatus.IN_SYNC);
}
@Test
@@ -236,14 +243,14 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// check initial status
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.UNKNOWN);
.as("wrong update status").isEqualTo(TargetUpdateStatus.UNKNOWN);
// assign the two sets in a row
Action firstAction = assignSet(target, dsFirst);
Action secondAction = assignSet(target, dsSecond);
assertThat(actionRepository.findAll()).hasSize(2);
assertThat(actionStatusRepository.findAll()).hasSize(2);
assertThat(actionRepository.findAll()).as("wrong size of actions").hasSize(2);
assertThat(actionStatusRepository.findAll()).as("wrong size of action status").hasSize(2);
// we cancel first -> second is left
deploymentManagement.cancelAction(firstAction,
@@ -253,26 +260,28 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
firstAction.setStatus(Status.CANCELED);
controllerManagement.addCancelActionStatus(
new ActionStatus(firstAction, Status.CANCELED, System.currentTimeMillis()), firstAction);
assertThat(actionStatusRepository.findAll()).hasSize(4);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet()).isEqualTo(dsSecond);
assertThat(actionStatusRepository.findAll()).as("wrong size of action status").hasSize(4);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet())
.as("wrong assigned ds").isEqualTo(dsSecond);
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.PENDING);
.as("wrong target update status").isEqualTo(TargetUpdateStatus.PENDING);
// we cancel second -> remain assigned until finished cancellation
deploymentManagement.cancelAction(secondAction,
targetManagement.findTargetByControllerID(target.getControllerId()));
secondAction = deploymentManagement.findActionWithDetails(secondAction.getId());
assertThat(actionStatusRepository.findAll()).hasSize(5);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet()).isEqualTo(dsSecond);
assertThat(actionStatusRepository.findAll()).as("wrong size of action status").hasSize(5);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet())
.as("wrong assigned ds").isEqualTo(dsSecond);
// confirm cancellation
secondAction.setStatus(Status.CANCELED);
controllerManagement.addCancelActionStatus(
new ActionStatus(secondAction, Status.CANCELED, System.currentTimeMillis()), secondAction);
// cancelled success -> back to dsInstalled
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet())
.isEqualTo(dsInstalled);
.as("wrong installed ds").isEqualTo(dsInstalled);
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.IN_SYNC);
.as("wrong target info update status").isEqualTo(TargetUpdateStatus.IN_SYNC);
}
@Test
@@ -291,13 +300,13 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// verify initial status
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.UNKNOWN);
.as("wrong target info update status").isEqualTo(TargetUpdateStatus.UNKNOWN);
Action assigningAction = assignSet(target, ds);
// verify assignment
assertThat(actionRepository.findAll()).hasSize(1);
assertThat(actionStatusRepository.findAll()).hasSize(1);
assertThat(actionRepository.findAll()).as("wrong size of action").hasSize(1);
assertThat(actionStatusRepository.findAll()).as("wrong size of action status").hasSize(1);
target = targetManagement.findTargetByControllerID(target.getControllerId());
@@ -310,11 +319,11 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
assigningAction = deploymentManagement.findActionWithDetails(assigningAction.getId());
// verify
assertThat(assigningAction.getStatus()).isEqualTo(Status.CANCELED);
assertThat(assigningAction.getStatus()).as("wrong size of status").isEqualTo(Status.CANCELED);
assertThat(targetManagement.findTargetByControllerID("4712").getAssignedDistributionSet())
.isEqualTo(dsInstalled);
.as("wrong assigned ds").isEqualTo(dsInstalled);
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.IN_SYNC);
.as("wrong target update status").isEqualTo(TargetUpdateStatus.IN_SYNC);
}
@Test
@@ -333,13 +342,13 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// verify initial status
assertThat(targetManagement.findTargetByControllerID("4712").getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.UNKNOWN);
.as("wrong update status").isEqualTo(TargetUpdateStatus.UNKNOWN);
final Action assigningAction = assignSet(target, ds);
// verify assignment
assertThat(actionRepository.findAll()).hasSize(1);
assertThat(actionStatusRepository.findAll()).hasSize(1);
assertThat(actionRepository.findAll()).as("wrong size of action").hasSize(1);
assertThat(actionStatusRepository.findAll()).as("wrong size of action status").hasSize(1);
// force quit assignment
try {
@@ -354,11 +363,11 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
deploymentManagement.assignDistributionSet(ds.getId(), new String[] { target.getControllerId() });
assertThat(
targetManagement.findTargetByControllerID(target.getControllerId()).getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.PENDING);
.as("wrong update status").isEqualTo(TargetUpdateStatus.PENDING);
assertThat(targetManagement.findTargetByControllerID(target.getControllerId()).getAssignedDistributionSet())
.isEqualTo(ds);
.as("wrong assigned ds").isEqualTo(ds);
final Action action = actionRepository.findByTargetAndDistributionSet(pageReq, target, ds).getContent().get(0);
assertThat(action).isNotNull();
assertThat(action).as("action should not be null").isNotNull();
return action;
}
@@ -390,26 +399,30 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
deploymentManagement.assignDistributionSet(ds, savedDeployedTargets);
// verify that one Action for each assignDistributionSet
assertThat(actionRepository.findAll(pageReq).getNumberOfElements()).isEqualTo(20);
assertThat(actionRepository.findAll(pageReq).getNumberOfElements()).as("wrong size of actions").isEqualTo(20);
final Iterable<Target> allFoundTargets = targetManagement.findTargetsAll(pageReq).getContent();
assertThat(allFoundTargets).containsAll(savedDeployedTargets).containsAll(savedNakedTargets);
assertThat(savedDeployedTargets).doesNotContain(Iterables.toArray(savedNakedTargets, Target.class));
assertThat(savedNakedTargets).doesNotContain(Iterables.toArray(savedDeployedTargets, Target.class));
assertThat(allFoundTargets).as("founded targets are wrong").containsAll(savedDeployedTargets)
.containsAll(savedNakedTargets);
assertThat(savedDeployedTargets).as("saved target are wrong")
.doesNotContain(Iterables.toArray(savedNakedTargets, Target.class));
assertThat(savedNakedTargets).as("saved target are wrong")
.doesNotContain(Iterables.toArray(savedDeployedTargets, Target.class));
for (final Target myt : savedNakedTargets) {
final Target t = targetManagement.findTargetByControllerID(myt.getControllerId());
assertThat(deploymentManagement.findActionsByTarget(t)).isEmpty();
assertThat(deploymentManagement.findActionsByTarget(t)).as("action should be empty").isEmpty();
}
for (final Target myt : savedDeployedTargets) {
final Target t = targetManagement.findTargetByControllerID(myt.getControllerId());
final List<Action> activeActionsByTarget = deploymentManagement.findActiveActionsByTarget(t);
assertThat(activeActionsByTarget).isNotEmpty();
assertThat(t.getTargetInfo().getUpdateStatus()).isEqualTo(TargetUpdateStatus.PENDING);
assertThat(activeActionsByTarget).as("action should not be empty").isNotEmpty();
assertThat(t.getTargetInfo().getUpdateStatus()).as("wrong target update status")
.isEqualTo(TargetUpdateStatus.PENDING);
for (final Action ua : activeActionsByTarget) {
assertThat(ua.getDistributionSet()).isEqualTo(ds);
assertThat(ua.getDistributionSet()).as("action has wrong ds").isEqualTo(ds);
}
}
@@ -448,12 +461,13 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// give some chance to receive events asynchronously
Thread.sleep(300);
final List<TargetAssignDistributionSetEvent> events = eventHandlerMock.getEvents(1, TimeUnit.MILLISECONDS);
assertThat(events).isEmpty();
assertThat(events).as("events should be empty").isEmpty();
final EventHandlerMock eventHandlerMockAfterCompletionOfDs = new EventHandlerMock(10);
eventBus.register(eventHandlerMockAfterCompletionOfDs);
assertThat(deploymentManagement.assignDistributionSet(nowComplete, targets).getAssigned()).isEqualTo(10);
assertThat(deploymentManagement.assignDistributionSet(nowComplete, targets).getAssigned())
.as("assign ds doesn't work").isEqualTo(10);
assertTargetAssignDistributionSetEvents(targets, nowComplete,
eventHandlerMockAfterCompletionOfDs.getEvents(10, TimeUnit.SECONDS));
}
@@ -493,7 +507,8 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// retrieving all Actions created by the assignDistributionSet call
final Page<Action> page = actionRepository.findAll(pageReq);
// and verify the number
assertThat(page.getTotalElements()).isEqualTo(noOfDeployedTargets * noOfDistributionSets);
assertThat(page.getTotalElements()).as("wrong size of actions")
.isEqualTo(noOfDeployedTargets * noOfDistributionSets);
// only records retrieved from the DB can be evaluated to be sure that
// all fields are
@@ -504,17 +519,20 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final Iterable<Target> undeployedTargetsFromDB = targetRepository.findAll(undeployedTargetIDs);
// test that number of Targets
assertThat(allFoundTargets.spliterator().getExactSizeIfKnown())
assertThat(allFoundTargets.spliterator().getExactSizeIfKnown()).as("number of target is wrong")
.isEqualTo(deployedTargetsFromDB.spliterator().getExactSizeIfKnown()
+ undeployedTargetsFromDB.spliterator().getExactSizeIfKnown());
assertThat(deployedTargetsFromDB.spliterator().getExactSizeIfKnown()).isEqualTo(noOfDeployedTargets);
assertThat(undeployedTargetsFromDB.spliterator().getExactSizeIfKnown()).isEqualTo(noOfUndeployedTargets);
assertThat(deployedTargetsFromDB.spliterator().getExactSizeIfKnown()).as("number of target is wrong")
.isEqualTo(noOfDeployedTargets);
assertThat(undeployedTargetsFromDB.spliterator().getExactSizeIfKnown()).as("number of target is wrong")
.isEqualTo(noOfUndeployedTargets);
// test the content of different lists
assertThat(allFoundTargets).containsAll(deployedTargetsFromDB).containsAll(undeployedTargetsFromDB);
assertThat(deployedTargetsFromDB).containsAll(savedDeployedTargets)
assertThat(allFoundTargets).as("content of founded target is wrong").containsAll(deployedTargetsFromDB)
.containsAll(undeployedTargetsFromDB);
assertThat(deployedTargetsFromDB).as("content of deployed target is wrong").containsAll(savedDeployedTargets)
.doesNotContain(Iterables.toArray(undeployedTargetsFromDB, Target.class));
assertThat(undeployedTargetsFromDB).containsAll(savedNakedTargets)
assertThat(undeployedTargetsFromDB).as("content of undeployed target is wrong").containsAll(savedNakedTargets)
.doesNotContain(Iterables.toArray(deployedTargetsFromDB, Target.class));
// For each of the 4 targets 1 distribution sets gets assigned
@@ -542,42 +560,42 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final DistributionSet dsC = deployResWithDsC.getDistributionSets().get(0);
// retrieving the UpdateActions created by the assignments
final Action updActA = actionRepository.findByDistributionSet(pageRequest, dsA).getContent().get(0);
final Action updActB = actionRepository.findByDistributionSet(pageRequest, dsB).getContent().get(0);
final Action updActC = actionRepository.findByDistributionSet(pageRequest, dsC).getContent().get(0);
actionRepository.findByDistributionSet(pageRequest, dsA).getContent().get(0);
actionRepository.findByDistributionSet(pageRequest, dsB).getContent().get(0);
actionRepository.findByDistributionSet(pageRequest, dsC).getContent().get(0);
// verifying the correctness of the assignments
for (final Target t : deployResWithDsA.getDeployedTargets()) {
assertThat(t.getAssignedDistributionSet().getId()).isEqualTo(dsA.getId());
assertThat(t.getAssignedDistributionSet().getId()).as("assignment is not correct").isEqualTo(dsA.getId());
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo()
.getInstalledDistributionSet()).isNull();
.getInstalledDistributionSet()).as("installed ds should be null").isNull();
}
for (final Target t : deployResWithDsB.getDeployedTargets()) {
assertThat(t.getAssignedDistributionSet().getId()).isEqualTo(dsB.getId());
assertThat(t.getAssignedDistributionSet().getId()).as("assigned ds is wrong").isEqualTo(dsB.getId());
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo()
.getInstalledDistributionSet()).isNull();
.getInstalledDistributionSet()).as("installed ds should be null").isNull();
}
for (final Target t : deployResWithDsC.getDeployedTargets()) {
assertThat(t.getAssignedDistributionSet().getId()).isEqualTo(dsC.getId());
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo()
.getInstalledDistributionSet()).isNull();
.getInstalledDistributionSet()).as("installed ds should not be null").isNull();
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.PENDING);
.as("wrong target info update status").isEqualTo(TargetUpdateStatus.PENDING);
}
final List<Target> updatedTsDsA = sendUpdateActionStatusToTargets(dsA, deployResWithDsA.getDeployedTargets(),
Status.FINISHED, new String[] { "alles gut" });
// verify, that dsA is deployed correctly
assertThat(updatedTsDsA).isEqualTo(deployResWithDsA.getDeployedTargets());
assertThat(updatedTsDsA).as("ds is not deployed correctly").isEqualTo(deployResWithDsA.getDeployedTargets());
for (final Target t_ : updatedTsDsA) {
final Target t = targetManagement.findTargetByControllerID(t_.getControllerId());
assertThat(t.getAssignedDistributionSet()).isEqualTo(dsA);
assertThat(t.getAssignedDistributionSet()).as("assigned ds is wrong").isEqualTo(dsA);
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo()
.getInstalledDistributionSet()).isEqualTo(dsA);
.getInstalledDistributionSet()).as("installed ds is wrong").isEqualTo(dsA);
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.IN_SYNC);
assertThat(deploymentManagement.findActiveActionsByTarget(t)).hasSize(0);
.as("wrong target info update status").isEqualTo(TargetUpdateStatus.IN_SYNC);
assertThat(deploymentManagement.findActiveActionsByTarget(t)).as("no actions should be active").hasSize(0);
}
// deploy dsA to the target which already have dsB deployed -> must
@@ -586,18 +604,18 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// UpdateAction for dsA
final Iterable<Target> deployed2DS = deploymentManagement
.assignDistributionSet(dsA, deployResWithDsB.getDeployedTargets()).getAssignedTargets();
final Action updActA2 = actionRepository.findByDistributionSet(pageRequest, dsA).getContent().get(1);
actionRepository.findByDistributionSet(pageRequest, dsA).getContent().get(1);
assertThat(deployed2DS).containsAll(deployResWithDsB.getDeployedTargets());
assertThat(deployed2DS).hasSameSizeAs(deployResWithDsB.getDeployedTargets());
assertThat(deployed2DS).as("deployed ds is wrong").containsAll(deployResWithDsB.getDeployedTargets());
assertThat(deployed2DS).as("deployed ds is wrong").hasSameSizeAs(deployResWithDsB.getDeployedTargets());
for (final Target t_ : deployed2DS) {
final Target t = targetManagement.findTargetByControllerID(t_.getControllerId());
assertThat(t.getAssignedDistributionSet()).isEqualTo(dsA);
assertThat(t.getAssignedDistributionSet()).as("assigned ds is wrong").isEqualTo(dsA);
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo()
.getInstalledDistributionSet()).isNull();
.getInstalledDistributionSet()).as("installed ds should be null").isNull();
assertThat(targetManagement.findTargetByControllerID(t.getControllerId()).getTargetInfo().getUpdateStatus())
.isEqualTo(TargetUpdateStatus.PENDING);
.as("wrong target info update status").isEqualTo(TargetUpdateStatus.PENDING);
}
}
@@ -630,22 +648,22 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
distributionSetManagement.deleteDistributionSet(dsA.getId());
dsA = distributionSetManagement.findDistributionSetById(dsA.getId());
assertThat(dsA).isNull();
assertThat(dsA).as("ds should be null").isNull();
// // verify that the ds is not physically deleted
for (final DistributionSet ds : deploymentResult.getDistributionSets()) {
distributionSetManagement.deleteDistributionSet(ds.getId());
final DistributionSet foundDS = distributionSetManagement.findDistributionSetById(ds.getId());
assertThat(foundDS).isNotNull();
assertThat(foundDS.isDeleted()).isTrue();
assertThat(foundDS).as("founded should not be null").isNotNull();
assertThat(foundDS.isDeleted()).as("founded ds should be deleted").isTrue();
}
// verify that deleted attribute is used correctly
List<DistributionSet> allFoundDS = distributionSetManagement.findDistributionSetsAll(pageReq, false, true)
.getContent();
assertThat(allFoundDS.size()).isEqualTo(0);
assertThat(allFoundDS.size()).as("no ds should be founded").isEqualTo(0);
allFoundDS = distributionSetManagement.findDistributionSetsAll(pageRequest, true, true).getContent();
assertThat(allFoundDS).hasSize(noOfDistributionSets);
assertThat(allFoundDS).as("wrong size of founded ds").hasSize(noOfDistributionSets);
for (final DistributionSet ds : deploymentResult.getDistributionSets()) {
sendUpdateActionStatusToTargets(ds, deploymentResult.getDeployedTargets(), Status.FINISHED,
@@ -659,9 +677,9 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// successfully and no activeAction is referring to created distribution
// sets
allFoundDS = distributionSetManagement.findDistributionSetsAll(pageRequest, false, true).getContent();
assertThat(allFoundDS.size()).isEqualTo(0);
assertThat(allFoundDS.size()).as("no ds should be founded").isEqualTo(0);
allFoundDS = distributionSetManagement.findDistributionSetsAll(pageRequest, true, true).getContent();
assertThat(allFoundDS).hasSize(noOfDistributionSets);
assertThat(allFoundDS).as("size of founded ds is wrong").hasSize(noOfDistributionSets);
}
@@ -685,15 +703,15 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
"blabla alles gut");
}
assertThat(targetManagement.countTargetsAll()).isNotZero();
assertThat(actionStatusRepository.count()).isNotZero();
assertThat(targetManagement.countTargetsAll()).as("size of targets is wrong").isNotZero();
assertThat(actionStatusRepository.count()).as("size of action status is wrong").isNotZero();
targetManagement
.deleteTargets(deploymentResult.getUndeployedTargetIDs().toArray(new Long[noOfUndeployedTargets]));
targetManagement.deleteTargets(deploymentResult.getDeployedTargetIDs().toArray(new Long[noOfDeployedTargets]));
assertThat(targetManagement.countTargetsAll()).isZero();
assertThat(actionStatusRepository.count()).isZero();
assertThat(targetManagement.countTargetsAll()).as("size of targets should be zero").isZero();
assertThat(actionStatusRepository.count()).as("size of action status is wrong").isZero();
}
private List<Target> sendUpdateActionStatusToTargets(final DistributionSet dsA, final Iterable<Target> targs,
@@ -744,7 +762,7 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
// checking the revisions of the created entities
// verifying that the revision of the object and the revision within the
// DB has not changed
assertThat(dsA.getOptLockRevision()).isEqualTo(
assertThat(dsA.getOptLockRevision()).as("lock revision is wrong").isEqualTo(
distributionSetManagement.findDistributionSetByIdWithDetails(dsA.getId()).getOptLockRevision());
// verifying that the assignment is correct
@@ -795,12 +813,11 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
public void checkThatDsRevisionsIsNotChangedWithTargetAssignment() {
final DistributionSet dsA = TestDataUtil.generateDistributionSet("a", softwareManagement,
distributionSetManagement);
final DistributionSet dsB = TestDataUtil.generateDistributionSet("b", softwareManagement,
distributionSetManagement);
TestDataUtil.generateDistributionSet("b", softwareManagement, distributionSetManagement);
Target targ = targetManagement
.createTarget(TestDataUtil.buildTargetFixture("target-id-A", "first description"));
assertThat(dsA.getOptLockRevision()).isEqualTo(
assertThat(dsA.getOptLockRevision()).as("lock revision is wrong").isEqualTo(
distributionSetManagement.findDistributionSetByIdWithDetails(dsA.getId()).getOptLockRevision());
final List<Target> targs = new ArrayList<Target>();
@@ -808,7 +825,7 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final Iterable<Target> savedTargs = deploymentManagement.assignDistributionSet(dsA, targs).getAssignedTargets();
targ = savedTargs.iterator().next();
assertThat(dsA.getOptLockRevision()).isEqualTo(
assertThat(dsA.getOptLockRevision()).as("lock revision is wrong").isEqualTo(
distributionSetManagement.findDistributionSetByIdWithDetails(dsA.getId()).getOptLockRevision());
}
@@ -825,14 +842,14 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final Action action = deploymentManagement.findActionWithDetails(assignDistributionSet.getActions().get(0));
// verify preparation
Action findAction = deploymentManagement.findAction(action.getId());
assertThat(findAction.getActionType()).isEqualTo(ActionType.SOFT);
assertThat(findAction.getActionType()).as("action type is wrong").isEqualTo(ActionType.SOFT);
// test
deploymentManagement.forceTargetAction(action.getId());
// verify test
findAction = deploymentManagement.findAction(action.getId());
assertThat(findAction.getActionType()).isEqualTo(ActionType.FORCED);
assertThat(findAction.getActionType()).as("action type is wrong").isEqualTo(ActionType.FORCED);
}
@Test
@@ -848,15 +865,15 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final Action action = deploymentManagement.findActionWithDetails(assignDistributionSet.getActions().get(0));
// verify perparation
Action findAction = deploymentManagement.findAction(action.getId());
assertThat(findAction.getActionType()).isEqualTo(ActionType.FORCED);
assertThat(findAction.getActionType()).as("action type is wrong").isEqualTo(ActionType.FORCED);
// test
final Action forceTargetAction = deploymentManagement.forceTargetAction(action.getId());
// verify test
assertThat(forceTargetAction.getActionType()).isEqualTo(ActionType.FORCED);
assertThat(forceTargetAction.getActionType()).as("action type is wrong").isEqualTo(ActionType.FORCED);
findAction = deploymentManagement.findAction(action.getId());
assertThat(findAction.getActionType()).isEqualTo(ActionType.FORCED);
assertThat(findAction.getActionType()).as("action type is wrong").isEqualTo(ActionType.FORCED);
}
/**
@@ -918,14 +935,14 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
if (event.getControllerId().equals(myt.getControllerId())) {
found = true;
final List<Action> activeActionsByTarget = deploymentManagement.findActiveActionsByTarget(myt);
assertThat(activeActionsByTarget).isNotEmpty();
assertThat(event.getActionId()).isEqualTo(activeActionsByTarget.get(0).getId())
.as("Action id in database and event do not match");
assertThat(event.getSoftwareModules())
assertThat(activeActionsByTarget).as("size of active actions for target is wrong").isNotEmpty();
assertThat(event.getActionId()).as("Action id in database and event do not match")
.isEqualTo(activeActionsByTarget.get(0).getId());
assertThat(event.getSoftwareModules()).as("softwaremodule size is not correct")
.containsOnly(ds.getModules().toArray(new SoftwareModule[ds.getModules().size()]));
}
}
assertThat(found).isTrue().as("No event found for controller " + myt.getControllerId());
assertThat(found).as("No event found for controller " + myt.getControllerId()).isTrue();
}
}
@@ -944,42 +961,19 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
private final List<Target> deployedTargets = new ArrayList<Target>();
private final List<DistributionSet> distributionSets = new ArrayList<DistributionSet>();
private final String undeployedTargetPrefix;
private final String deployedTargetPrefix;
private final String distributionSetPrefix;
public DeploymentResult(final Iterable<Target> deployedTs, final Iterable<Target> undeployedTs,
final Iterable<DistributionSet> dss, final String deployedTargetPrefix,
final String undeployedTargetPrefix, final String distributionSetPrefix) {
this.undeployedTargetPrefix = undeployedTargetPrefix;
this.deployedTargetPrefix = deployedTargetPrefix;
this.distributionSetPrefix = distributionSetPrefix;
Iterables.addAll(deployedTargets, deployedTs);
Iterables.addAll(undeployedTargets, undeployedTs);
Iterables.addAll(distributionSets, dss);
deployedTargets.forEach(new Consumer<Target>() {
@Override
public void accept(final Target t) {
deployedTargetIDs.add(t.getId());
}
});
deployedTargets.forEach(t -> deployedTargetIDs.add(t.getId()));
undeployedTargets.forEach(new Consumer<Target>() {
@Override
public void accept(final Target t) {
undeployedTargetIDs.add(t.getId());
}
});
undeployedTargets.forEach(t -> undeployedTargetIDs.add(t.getId()));
distributionSets.forEach(new Consumer<DistributionSet>() {
@Override
public void accept(final DistributionSet ds) {
distributionSetIDs.add(ds.getId());
}
});
distributionSets.forEach(ds -> distributionSetIDs.add(ds.getId()));
}
@@ -1018,27 +1012,6 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
return deployedTargets;
}
/**
* @return the noOfUndeployedTargets
*/
public int getNoOfUndeployedTargets() {
return undeployedTargetIDs.size();
}
/**
* @return the noOfDeployedTargets
*/
public int getNoOfDeployedTargets() {
return deployedTargetIDs.size();
}
/**
* @return the noOfDistributionSets
*/
public int getNoOfDistributionSets() {
return distributionSets.size();
}
/**
* @return the undeployedTargetIDs
*/
@@ -1046,26 +1019,6 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
return undeployedTargetIDs;
}
/**
* @return the undeployedTargetPrefix
*/
public String getUndeployedTargetPrefix() {
return undeployedTargetPrefix;
}
/**
* @return the deployedTargetPrefix
*/
public String getDeployedTargetPrefix() {
return deployedTargetPrefix;
}
/**
* @return the distributionSetPrefix
*/
public String getDistributionSetPrefix() {
return distributionSetPrefix;
}
}
private static class EventHandlerMock {
@@ -1090,9 +1043,9 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
latch.await(timeout, unit);
final List<TargetAssignDistributionSetEvent> handledEvents = new LinkedList<TargetAssignDistributionSetEvent>(
events);
assertThat(handledEvents).hasSize(expectedNumberOfEvents)
.as("Did not receive the expected amount of events (" + expectedNumberOfEvents
+ ") within timeout. Received events are " + handledEvents);
assertThat(handledEvents).as("Did not receive the expected amount of events (" + expectedNumberOfEvents
+ ") within timeout. Received events are " + handledEvents).hasSize(expectedNumberOfEvents);
return handledEvents;
}
}
@@ -1118,9 +1071,8 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
throws InterruptedException {
latch.await(timeout, unit);
final List<CancelTargetAssignmentEvent> handledEvents = new LinkedList<CancelTargetAssignmentEvent>(events);
assertThat(handledEvents).hasSize(expectedNumberOfEvents)
.as("Did not receive the expected amount of events (" + expectedNumberOfEvents
+ ") within timeout. Received events are " + handledEvents);
assertThat(handledEvents).as("Did not receive the expected amount of events (" + expectedNumberOfEvents
+ ") within timeout. Received events are " + handledEvents).hasSize(expectedNumberOfEvents);
return handledEvents;
}
}

48
hawkbit-repository/src/test/java/org/eclipse/hawkbit/repository/ReportManagementTest.java
View File

@@ -18,7 +18,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.stream.Collectors;
import org.eclipse.hawkbit.AbstractIntegrationTest;
@@ -96,7 +95,8 @@ public class ReportManagementTest extends AbstractIntegrationTest {
// +1 because we go back #maxMonthBackAmountReportTargets but in the
// report the current month
// is included for sure, so from this month we go back
assertThat(targetsCreatedOverPeriod.getData()).hasSize(maxMonthBackAmountReportTargets + 1);
assertThat(targetsCreatedOverPeriod.getData()).as("created over period has wrong size")
.hasSize(maxMonthBackAmountReportTargets + 1);
for (final DataReportSeriesItem<LocalDate> reportItem : targetsCreatedOverPeriod.getData()) {
// only one target is created for each month
assertThat(reportItem.getData().intValue()).as("Target for each month").isEqualTo(1);
@@ -147,10 +147,11 @@ public class ReportManagementTest extends AbstractIntegrationTest {
// +1 because we go back #maxMonthBackAmountReportTargets but in the
// report the current month
// is included for sure, so from this month we go back
assertThat(feedbackReceivedOverTime.getData()).hasSize(maxMonthBackAmountReportTargets + 1);
assertThat(feedbackReceivedOverTime.getData()).as("feedback receiver has wrong data size")
.hasSize(maxMonthBackAmountReportTargets + 1);
for (final DataReportSeriesItem<LocalDate> reportItem : feedbackReceivedOverTime.getData()) {
// only one target feedback is created for each month
assertThat(reportItem.getData().intValue()).isEqualTo(1);
assertThat(reportItem.getData().intValue()).as("data size is wrong").isEqualTo(1);
}
// check cache evict
@@ -165,7 +166,7 @@ public class ReportManagementTest extends AbstractIntegrationTest {
}
feedbackReceivedOverTime = reportManagement.feedbackReceivedOverTime(DateTypes.perMonth(), from, to);
for (final DataReportSeriesItem<LocalDate> reportItem : feedbackReceivedOverTime.getData()) {
assertThat(reportItem.getData().intValue()).isEqualTo(2);
assertThat(reportItem.getData().intValue()).as("report item has wrong data size").isEqualTo(2);
}
}
@@ -227,12 +228,12 @@ public class ReportManagementTest extends AbstractIntegrationTest {
.isEqualTo(3L);
final DataReportSeriesItem<String>[] outerData = innerOuterDataReportSeries.getOuterSeries().getData();
assertThat(Arrays.stream(outerData).map(DataReportSeriesItem::getType).collect(Collectors.toList()))
.contains("0.0.0", "0.0.1");
.as("versio item contains wrong version").contains("0.0.0", "0.0.1");
} else if (dataReportSeriesItem.getType().equals("ds2")) {
assertThat(dataReportSeriesItem.getData()).as("Version/Item type of DistributionSet 2 in statistics")
.isEqualTo(1L);
final DataReportSeriesItem<String>[] outerData = innerOuterDataReportSeries.getOuterSeries().getData();
assertThat(outerData).hasSize(1);
assertThat(outerData).as("Version/Item type has wrong size").hasSize(1);
assertThat(outerData[0].getType()).as("Version/Item type of DistributionSet 2 in statistics")
.isEqualTo("0.0.2");
} else if (dataReportSeriesItem.getType().equals("ds3")) {
@@ -240,7 +241,7 @@ public class ReportManagementTest extends AbstractIntegrationTest {
assertThat(dataReportSeriesItem.getData()).as("Version/Item type of DistributionSet 3 in statistics")
.isEqualTo(0L);
final DataReportSeriesItem<String>[] outerData = innerOuterDataReportSeries.getOuterSeries().getData();
assertThat(outerData).hasSize(1);
assertThat(outerData).as("Version/Item type has wrong size").hasSize(1);
assertThat(outerData[0].getType()).as("Version/Item type of DistributionSet 3 in statistics")
.isEqualTo("0.0.3");
} else {
@@ -395,13 +396,13 @@ public class ReportManagementTest extends AbstractIntegrationTest {
final DataReportSeriesItem<String>[] outerData = innerOuterDataReportSeries.getOuterSeries().getData();
assertThat(Arrays.stream(outerData).map(DataReportSeriesItem::getType).collect(Collectors.toList()))
.contains("0.0.0", "0.0.1");
.as("Out series contains wrong version").contains("0.0.0", "0.0.1");
} else if (dataReportSeriesItem.getType().equals("ds2")) {
assertThat(dataReportSeriesItem.getData()).as("Total count of DistributionSet 2 in statistics")
.isEqualTo(1L);
final DataReportSeriesItem<String>[] outerData = innerOuterDataReportSeries.getOuterSeries().getData();
assertThat(outerData).hasSize(1);
assertThat(outerData).as("out series has wrong size").hasSize(1);
assertThat(outerData[0].getType()).as("Version/Item type of DistributionSet 2 in statistics")
.isEqualTo("0.0.2");
@@ -409,7 +410,7 @@ public class ReportManagementTest extends AbstractIntegrationTest {
assertThat(dataReportSeriesItem.getData()).as("Total count of DistributionSet 3 in statistics")
.isEqualTo(0L);
final DataReportSeriesItem<String>[] outerData = innerOuterDataReportSeries.getOuterSeries().getData();
assertThat(outerData).hasSize(1);
assertThat(outerData).as("out series has wrong size").hasSize(1);
assertThat(outerData[0].getType()).as("Version/Item type of DistributionSet 3 in statistics")
.isEqualTo("0.0.3");
} else {
@@ -487,33 +488,26 @@ public class ReportManagementTest extends AbstractIntegrationTest {
final int targetCreateAmount = 10;
// create targets for another tenant
securityRule.runAs(WithSpringAuthorityRule.withUserAndTenant("user", "anotherTenant"), new Callable<Void>() {
@Override
public Void call() throws Exception {
for (int index = 0; index < targetCreateAmount; index++) {
targetManagement.createTarget(new Target("t" + index));
}
return null;
securityRule.runAs(WithSpringAuthorityRule.withUserAndTenant("user", "anotherTenant"), () -> {
for (int index = 0; index < targetCreateAmount; index++) {
targetManagement.createTarget(new Target("t" + index));
}
return null;
});
// ensure targets has been created for 'anotherTenant'
final Slice<Target> targetsForAnotherTenant = securityRule.runAs(
WithSpringAuthorityRule.withUserAndTenant("user", "anotherTenant"), new Callable<Slice<Target>>() {
@Override
public Slice<Target> call() throws Exception {
return targetManagement.findTargetsAll(new PageRequest(0, 1000));
}
});
assertThat(targetsForAnotherTenant).hasSize(targetCreateAmount);
WithSpringAuthorityRule.withUserAndTenant("user", "anotherTenant"),
() -> targetManagement.findTargetsAll(new PageRequest(0, 1000)));
assertThat(targetsForAnotherTenant).as("targets has wrong size").hasSize(targetCreateAmount);
final LocalDateTime to = LocalDateTime.now();
final LocalDateTime from = to.minusMonths(targetCreateAmount);
// now retrieve the report for the 'mytenant'
final DataReportSeries<LocalDate> targetsCreatedOverPeriod = reportManagement
.targetsCreatedOverPeriod(DateTypes.perMonth(), from, to);
// final no targets should final be created for this tenant
assertThat(targetsCreatedOverPeriod.getData()).hasSize(0);
assertThat(targetsCreatedOverPeriod.getData()).as("final no targets should final be created for this tenant")
.hasSize(0);
}