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

refactored test data generation. Refactored entity factor methods.

Browse Source 
Signed-off-by: Kai Zimmermann <kai.zimmermann@bosch-si.com>
This commit is contained in:
Kai Zimmermann
2016-05-31 08:51:49 +02:00
parent a4e0fc2457
commit 7a98c58407
137 changed files with 2937 additions and 2593 deletions
Download Patch File Download Diff File Expand all files Collapse all files

333
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/AbstractIntegrationTest.java
View File

@@ -1,333 +0,0 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import static org.fest.assertions.api.Assertions.assertThat;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.eclipse.hawkbit.ExcludePathAwareShallowETagFilter;
import org.eclipse.hawkbit.RepositoryApplicationConfiguration;
import org.eclipse.hawkbit.cache.TenantAwareCacheManager;
import org.eclipse.hawkbit.repository.ArtifactManagement;
import org.eclipse.hawkbit.repository.ControllerManagement;
import org.eclipse.hawkbit.repository.DeploymentManagement;
import org.eclipse.hawkbit.repository.DistributionSetManagement;
import org.eclipse.hawkbit.repository.RolloutGroupManagement;
import org.eclipse.hawkbit.repository.RolloutManagement;
import org.eclipse.hawkbit.repository.SoftwareManagement;
import org.eclipse.hawkbit.repository.SystemManagement;
import org.eclipse.hawkbit.repository.TagManagement;
import org.eclipse.hawkbit.repository.TargetFilterQueryManagement;
import org.eclipse.hawkbit.repository.TargetManagement;
import org.eclipse.hawkbit.repository.TenantConfigurationManagement;
import org.eclipse.hawkbit.repository.jpa.ActionRepository;
import org.eclipse.hawkbit.repository.jpa.ActionStatusRepository;
import org.eclipse.hawkbit.repository.jpa.DistributionSetRepository;
import org.eclipse.hawkbit.repository.jpa.DistributionSetTagRepository;
import org.eclipse.hawkbit.repository.jpa.DistributionSetTypeRepository;
import org.eclipse.hawkbit.repository.jpa.ExternalArtifactRepository;
import org.eclipse.hawkbit.repository.jpa.LocalArtifactRepository;
import org.eclipse.hawkbit.repository.jpa.RolloutGroupRepository;
import org.eclipse.hawkbit.repository.jpa.RolloutRepository;
import org.eclipse.hawkbit.repository.jpa.SoftwareModuleMetadataRepository;
import org.eclipse.hawkbit.repository.jpa.SoftwareModuleRepository;
import org.eclipse.hawkbit.repository.jpa.SoftwareModuleTypeRepository;
import org.eclipse.hawkbit.repository.jpa.TargetInfoRepository;
import org.eclipse.hawkbit.repository.jpa.TargetRepository;
import org.eclipse.hawkbit.repository.jpa.TargetTagRepository;
import org.eclipse.hawkbit.repository.jpa.TenantMetaDataRepository;
import org.eclipse.hawkbit.repository.jpa.utils.RepositoryDataGenerator.DatabaseCleanupUtil;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
import org.eclipse.hawkbit.security.DosFilter;
import org.eclipse.hawkbit.security.SystemSecurityContext;
import org.eclipse.hawkbit.tenancy.TenantAware;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.rules.MethodRule;
import org.junit.rules.TestWatchman;
import org.junit.runner.RunWith;
import org.junit.runners.model.FrameworkMethod;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.data.auditing.AuditingHandler;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.mongodb.gridfs.GridFsOperations;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.annotation.DirtiesContext.ClassMode;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.DefaultMockMvcBuilder;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@SpringApplicationConfiguration(classes = { RepositoryApplicationConfiguration.class, TestConfiguration.class })
@ActiveProfiles({ "test" })
@WithUser(principal = "bumlux", allSpPermissions = true, authorities = "ROLE_CONTROLLER")
// destroy the context after each test class because otherwise we get problem
// when context is
// refreshed we e.g. get two instances of CacheManager which leads to very
// strange test failures.
@DirtiesContext(classMode = ClassMode.AFTER_CLASS)
public abstract class AbstractIntegrationTest implements EnvironmentAware {
protected static Logger LOG = null;
protected static final Pageable pageReq = new PageRequest(0, 400);
@PersistenceContext
protected EntityManager entityManager;
@Autowired
protected TargetRepository targetRepository;
@Autowired
protected ActionRepository actionRepository;
@Autowired
protected DistributionSetRepository distributionSetRepository;
@Autowired
protected SoftwareModuleRepository softwareModuleRepository;
@Autowired
protected TenantMetaDataRepository tenantMetaDataRepository;
@Autowired
protected DistributionSetTypeRepository distributionSetTypeRepository;
@Autowired
protected SoftwareModuleTypeRepository softwareModuleTypeRepository;
@Autowired
protected TargetTagRepository targetTagRepository;
@Autowired
protected DistributionSetTagRepository distributionSetTagRepository;
@Autowired
protected SoftwareModuleMetadataRepository softwareModuleMetadataRepository;
@Autowired
protected ActionStatusRepository actionStatusRepository;
@Autowired
protected ExternalArtifactRepository externalArtifactRepository;
@Autowired
protected SoftwareManagement softwareManagement;
@Autowired
protected DistributionSetManagement distributionSetManagement;
@Autowired
protected ControllerManagement controllerManagement;
@Autowired
protected TargetManagement targetManagement;
@Autowired
protected TargetFilterQueryManagement targetFilterQueryManagement;
@Autowired
protected TagManagement tagManagement;
@Autowired
protected DeploymentManagement deploymentManagement;
@Autowired
protected ArtifactManagement artifactManagement;
@Autowired
protected LocalArtifactRepository artifactRepository;
@Autowired
protected TargetInfoRepository targetInfoRepository;
@Autowired
protected GridFsOperations operations;
@Autowired
protected WebApplicationContext context;
@Autowired
protected ControllerManagement controllerManagament;
@Autowired
protected AuditingHandler auditingHandler;
@Autowired
protected TenantAware tenantAware;
@Autowired
protected SystemManagement systemManagement;
@Autowired
protected TenantAwareCacheManager cacheManager;
@Autowired
protected TenantConfigurationManagement tenantConfigurationManagement;
@Autowired
protected RolloutManagement rolloutManagement;
@Autowired
protected RolloutGroupManagement rolloutGroupManagement;
@Autowired
protected RolloutGroupRepository rolloutGroupRepository;
@Autowired
protected RolloutRepository rolloutRepository;
@Autowired
protected SystemSecurityContext systemSecurityContext;
protected MockMvc mvc;
@Autowired
protected DatabaseCleanupUtil dbCleanupUtil;
protected SoftwareModuleType osType;
protected SoftwareModuleType appType;
protected SoftwareModuleType runtimeType;
protected DistributionSetType standardDsType;
@Rule
public final WithSpringAuthorityRule securityRule = new WithSpringAuthorityRule();
protected Environment environment = null;
private static CIMySqlTestDatabase tesdatabase;
@Override
public void setEnvironment(final Environment environment) {
this.environment = environment;
}
@Before
public void before() throws Exception {
mvc = createMvcWebAppContext().build();
standardDsType = securityRule.runAsPrivileged(() -> systemManagement.getTenantMetadata().getDefaultDsType());
osType = securityRule.runAsPrivileged(() -> softwareManagement.findSoftwareModuleTypeByKey("os"));
osType.setDescription("Updated description to have lastmodified available in tests");
osType = securityRule.runAsPrivileged(() -> softwareManagement.updateSoftwareModuleType(osType));
appType = securityRule.runAsPrivileged(() -> softwareManagement.findSoftwareModuleTypeByKey("application"));
appType.setDescription("Updated description to have lastmodified available in tests");
appType = securityRule.runAsPrivileged(() -> softwareManagement.updateSoftwareModuleType(appType));
runtimeType = securityRule.runAsPrivileged(() -> softwareManagement.findSoftwareModuleTypeByKey("runtime"));
runtimeType.setDescription("Updated description to have lastmodified available in tests");
runtimeType = securityRule.runAsPrivileged(() -> softwareManagement.updateSoftwareModuleType(runtimeType));
}
protected DefaultMockMvcBuilder createMvcWebAppContext() {
return MockMvcBuilders.webAppContextSetup(context)
.addFilter(new DosFilter(100, 10, "127\\.0\\.0\\.1|\\[0:0:0:0:0:0:0:1\\]", "(^192\\.168\\.)",
"X-Forwarded-For"))
.addFilter(new ExcludePathAwareShallowETagFilter(
"/rest/v1/softwaremodules/{smId}/artifacts/{artId}/download", "/*/controller/artifacts/**"));
}
@BeforeClass
public static void beforeClass() {
createTestdatabaseAndStart();
}
private static void createTestdatabaseAndStart() {
if ("MYSQL".equals(System.getProperty("spring.jpa.database"))) {
tesdatabase = new CIMySqlTestDatabase();
tesdatabase.before();
}
}
@AfterClass
public static void afterClass() {
if (tesdatabase != null) {
tesdatabase.after();
}
}
@After
public void after() throws Exception {
deleteAllRepos();
cacheManager.getDirectCacheNames().forEach(name -> cacheManager.getDirectCache(name).clear());
assertThat(actionStatusRepository.findAll()).isEmpty();
assertThat(targetRepository.findAll()).isEmpty();
assertThat(actionRepository.findAll()).isEmpty();
assertThat(distributionSetRepository.findAll()).isEmpty();
assertThat(targetTagRepository.findAll()).isEmpty();
assertThat(distributionSetTagRepository.findAll()).isEmpty();
assertThat(softwareModuleRepository.findAll()).isEmpty();
assertThat(softwareModuleTypeRepository.findAll()).isEmpty();
assertThat(distributionSetTypeRepository.findAll()).isEmpty();
assertThat(tenantMetaDataRepository.findAll()).isEmpty();
assertThat(rolloutGroupRepository.findAll()).isEmpty();
assertThat(rolloutRepository.findAll()).isEmpty();
}
@Transactional
protected void deleteAllRepos() throws Exception {
final List<String> tenants = securityRule.runAs(WithSpringAuthorityRule.withUser(false),
() -> systemManagement.findTenants());
tenants.forEach(tenant -> {
try {
securityRule.runAs(WithSpringAuthorityRule.withUser(false), () -> {
systemManagement.deleteTenant(tenant);
return null;
});
} catch (final Exception e) {
e.printStackTrace();
}
});
}
@Rule
public MethodRule watchman = new TestWatchman() {
@Override
public void starting(final FrameworkMethod method) {
if (LOG != null) {
LOG.info("Starting Test {}...", method.getName());
}
}
@Override
public void succeeded(final FrameworkMethod method) {
if (LOG != null) {
LOG.info("Test {} succeeded.", method.getName());
}
}
@Override
public void failed(final Throwable e, final FrameworkMethod method) {
if (LOG != null) {
LOG.error("Test {} failed with {}.", method.getName(), e);
}
}
};
}

104
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/AbstractIntegrationTestWithMongoDB.java
View File

@@ -1,104 +0,0 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import java.io.IOException;
import java.net.UnknownHostException;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.springframework.data.mongodb.core.query.Query;
import de.flapdoodle.embed.mongo.Command;
import de.flapdoodle.embed.mongo.MongodExecutable;
import de.flapdoodle.embed.mongo.MongodStarter;
import de.flapdoodle.embed.mongo.config.ArtifactStoreBuilder;
import de.flapdoodle.embed.mongo.config.DownloadConfigBuilder;
import de.flapdoodle.embed.mongo.config.IMongodConfig;
import de.flapdoodle.embed.mongo.config.MongodConfigBuilder;
import de.flapdoodle.embed.mongo.config.Net;
import de.flapdoodle.embed.mongo.config.RuntimeConfigBuilder;
import de.flapdoodle.embed.mongo.distribution.Version;
import de.flapdoodle.embed.process.config.store.HttpProxyFactory;
import de.flapdoodle.embed.process.runtime.Network;
/**
* Test class that contains MonfoDb start and stop for the test
*
*
*
*
*/
public abstract class AbstractIntegrationTestWithMongoDB extends AbstractIntegrationTest {
protected static volatile MongodExecutable mongodExecutable = null;
private static final AtomicInteger mongoLease = new AtomicInteger(0);
private static volatile Integer port;
@BeforeClass
public static void setupMongo() throws UnknownHostException, IOException {
mongoLease.incrementAndGet();
if (mongodExecutable == null) {
final Command command = Command.MongoD;
final RuntimeConfigBuilder runtimeConfig = new RuntimeConfigBuilder().defaults(command);
if (port == null) {
port = new FreePortFileWriter(28017, 28090, "./target/freeports").getPort();
System.setProperty("spring.data.mongodb.port", String.valueOf(port));
}
Version version = Version.V3_0_8;
if (System.getProperty("inf.mongodb.version") != null) {
version = Version
.valueOf("V" + System.getProperty("inf.mongodb.version").trim().replaceAll("\\.", "_"));
}
if (System.getProperty("http.proxyHost") != null) {
runtimeConfig
.artifactStore(
new ArtifactStoreBuilder().defaults(command)
.download(new DownloadConfigBuilder().defaultsForCommand(command)
.proxyFactory(new HttpProxyFactory(
System.getProperty("http.proxyHost").trim(),
Integer.valueOf(System.getProperty("http.proxyPort"))))));
}
final IMongodConfig mongodConfig = new MongodConfigBuilder().version(version)
.net(new Net("127.0.0.1", port, Network.localhostIsIPv6())).build();
final MongodStarter starter = MongodStarter.getInstance(runtimeConfig.build());
mongodExecutable = starter.prepare(mongodConfig);
mongodExecutable.start();
}
}
@After
public void cleanCurrentCollection() {
operations.delete(new Query());
}
public void internalShutDownMongo() {
if (mongodExecutable != null && mongoLease.decrementAndGet() <= 0) {
mongodExecutable.stop();
mongodExecutable = null;
}
}
@AfterClass
public static void shutdownMongo() throws UnknownHostException, IOException {
if (mongodExecutable != null && mongoLease.decrementAndGet() <= 0) {
mongodExecutable.stop();
mongodExecutable = null;
}
port = null;
}
}

104
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/AbstractJpaIntegrationTest.java Normal file
View File

@@ -0,0 +1,104 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.eclipse.hawkbit.cache.TenantAwareCacheManager;
import org.eclipse.hawkbit.repository.util.AbstractIntegrationTest;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.data.mongodb.gridfs.GridFsOperations;
@SpringApplicationConfiguration(classes = { org.eclipse.hawkbit.RepositoryApplicationConfiguration.class,
TestConfiguration.class })
public abstract class AbstractJpaIntegrationTest extends AbstractIntegrationTest {
@PersistenceContext
protected EntityManager entityManager;
@Autowired
protected TargetRepository targetRepository;
@Autowired
protected ActionRepository actionRepository;
@Autowired
protected DistributionSetRepository distributionSetRepository;
@Autowired
protected SoftwareModuleRepository softwareModuleRepository;
@Autowired
protected TenantMetaDataRepository tenantMetaDataRepository;
@Autowired
protected DistributionSetTypeRepository distributionSetTypeRepository;
@Autowired
protected SoftwareModuleTypeRepository softwareModuleTypeRepository;
@Autowired
protected TargetTagRepository targetTagRepository;
@Autowired
protected DistributionSetTagRepository distributionSetTagRepository;
@Autowired
protected SoftwareModuleMetadataRepository softwareModuleMetadataRepository;
@Autowired
protected ActionStatusRepository actionStatusRepository;
@Autowired
protected ExternalArtifactRepository externalArtifactRepository;
@Autowired
protected LocalArtifactRepository artifactRepository;
@Autowired
protected TargetInfoRepository targetInfoRepository;
@Autowired
protected GridFsOperations operations;
@Autowired
protected RolloutGroupRepository rolloutGroupRepository;
@Autowired
protected RolloutRepository rolloutRepository;
@Autowired
protected TenantAwareCacheManager cacheManager;
private static CIMySqlTestDatabase tesdatabase;
@BeforeClass
public static void beforeClass() {
createTestdatabaseAndStart();
}
private static void createTestdatabaseAndStart() {
if ("MYSQL".equals(System.getProperty("spring.jpa.database"))) {
tesdatabase = new CIMySqlTestDatabase();
tesdatabase.before();
}
}
@AfterClass
public static void afterClass() {
if (tesdatabase != null) {
tesdatabase.after();
}
}
}

104
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/AbstractJpaIntegrationTestWithMongoDB.java Normal file
View File

@@ -0,0 +1,104 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.eclipse.hawkbit.cache.TenantAwareCacheManager;
import org.eclipse.hawkbit.repository.util.AbstractIntegrationTestWithMongoDB;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.data.mongodb.gridfs.GridFsOperations;
@SpringApplicationConfiguration(classes = { org.eclipse.hawkbit.RepositoryApplicationConfiguration.class,
TestConfiguration.class })
public abstract class AbstractJpaIntegrationTestWithMongoDB extends AbstractIntegrationTestWithMongoDB {
@PersistenceContext
protected EntityManager entityManager;
@Autowired
protected TargetRepository targetRepository;
@Autowired
protected ActionRepository actionRepository;
@Autowired
protected DistributionSetRepository distributionSetRepository;
@Autowired
protected SoftwareModuleRepository softwareModuleRepository;
@Autowired
protected TenantMetaDataRepository tenantMetaDataRepository;
@Autowired
protected DistributionSetTypeRepository distributionSetTypeRepository;
@Autowired
protected SoftwareModuleTypeRepository softwareModuleTypeRepository;
@Autowired
protected TargetTagRepository targetTagRepository;
@Autowired
protected DistributionSetTagRepository distributionSetTagRepository;
@Autowired
protected SoftwareModuleMetadataRepository softwareModuleMetadataRepository;
@Autowired
protected ActionStatusRepository actionStatusRepository;
@Autowired
protected ExternalArtifactRepository externalArtifactRepository;
@Autowired
protected LocalArtifactRepository artifactRepository;
@Autowired
protected TargetInfoRepository targetInfoRepository;
@Autowired
protected GridFsOperations operations;
@Autowired
protected RolloutGroupRepository rolloutGroupRepository;
@Autowired
protected RolloutRepository rolloutRepository;
@Autowired
protected TenantAwareCacheManager cacheManager;
private static CIMySqlTestDatabase tesdatabase;
@BeforeClass
public static void beforeClass() {
createTestdatabaseAndStart();
}
private static void createTestdatabaseAndStart() {
if ("MYSQL".equals(System.getProperty("spring.jpa.database"))) {
tesdatabase = new CIMySqlTestDatabase();
tesdatabase.before();
}
}
@AfterClass
public static void afterClass() {
if (tesdatabase != null) {
tesdatabase.after();
}
}
}

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

@@ -29,7 +29,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("Artifact Management")
public class ArtifactManagementNoMongoDbTest extends AbstractIntegrationTest {
public class ArtifactManagementNoMongoDbTest extends AbstractJpaIntegrationTest {
@BeforeClass
public static void initialize() {

3
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/ArtifactManagementTest.java
View File

@@ -32,6 +32,7 @@ import org.eclipse.hawkbit.repository.model.Artifact;
import org.eclipse.hawkbit.repository.model.ExternalArtifactProvider;
import org.eclipse.hawkbit.repository.model.LocalArtifact;
import org.eclipse.hawkbit.repository.model.SoftwareModule;
import org.eclipse.hawkbit.repository.util.WithUser;
import org.junit.Test;
import org.slf4j.LoggerFactory;
import org.springframework.data.mongodb.core.query.Criteria;
@@ -50,7 +51,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("Artifact Management")
public class ArtifactManagementTest extends AbstractIntegrationTestWithMongoDB {
public class ArtifactManagementTest extends AbstractJpaIntegrationTestWithMongoDB {
public ArtifactManagementTest() {
LOG = LoggerFactory.getLogger(ArtifactManagementTest.class);
}

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

@@ -33,14 +33,13 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("Controller Management")
public class ControllerManagementTest extends AbstractIntegrationTest {
public class ControllerManagementTest extends AbstractJpaIntegrationTest {
@Test
@Description("Controller adds a new action status.")
public void controllerAddsActionStatus() {
final Target target = new JpaTarget("4712");
final DistributionSet ds = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("");
Target savedTarget = targetManagement.createTarget(target);
final List<Target> toAssign = new ArrayList<>();
@@ -99,8 +98,7 @@ public class ControllerManagementTest extends AbstractIntegrationTest {
// mock
final Target target = new JpaTarget("Rabbit");
final DistributionSet ds = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("");
Target savedTarget = targetManagement.createTarget(target);
final List<Target> toAssign = new ArrayList<>();
toAssign.add(savedTarget);

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

@@ -67,7 +67,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("Deployment Management")
public class DeploymentManagementTest extends AbstractIntegrationTest {
public class DeploymentManagementTest extends AbstractJpaIntegrationTest {
@Autowired
private EventBus eventBus;
@@ -75,9 +75,9 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
@Test
@Description("Test verifies that the repistory retrieves the action including all defined (lazy) details.")
public void findActionWithLazyDetails() {
final DistributionSet testDs = TestDataUtil.generateDistributionSet("TestDs", "1.0", softwareManagement,
distributionSetManagement, new ArrayList<DistributionSetTag>());
final List<Target> testTarget = targetManagement.createTargets(TestDataUtil.generateTargets(1));
final DistributionSet testDs = testdataFactory.createDistributionSet("TestDs", "1.0",
new ArrayList<DistributionSetTag>());
final List<Target> testTarget = testdataFactory.createTargets(1);
// one action with one action status is generated
final Long actionId = deploymentManagement.assignDistributionSet(testDs, testTarget).getActions().get(0);
final Action action = deploymentManagement.findActionWithDetails(actionId);
@@ -91,9 +91,9 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
@Test
@Description("Test verifies that the custom query to find all actions include the count of action status is working correctly")
public void findActionsWithStatusCountByTarget() {
final DistributionSet testDs = TestDataUtil.generateDistributionSet("TestDs", "1.0", softwareManagement,
distributionSetManagement, new ArrayList<DistributionSetTag>());
final List<Target> testTarget = targetManagement.createTargets(TestDataUtil.generateTargets(1));
final DistributionSet testDs = testdataFactory.createDistributionSet("TestDs", "1.0",
new ArrayList<DistributionSetTag>());
final List<Target> testTarget = testdataFactory.createTargets(1);
// one action with one action status is generated
final Action action = deploymentManagement.findActionWithDetails(
deploymentManagement.assignDistributionSet(testDs, testTarget).getActions().get(0));
@@ -114,8 +114,8 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
public void assignAndUnassignDistributionSetToTag() {
final List<Long> assignDS = new ArrayList<>();
for (int i = 0; i < 4; i++) {
assignDS.add(TestDataUtil.generateDistributionSet("DS" + i, "1.0", softwareManagement,
distributionSetManagement, new ArrayList<DistributionSetTag>()).getId());
assignDS.add(testdataFactory.createDistributionSet("DS" + i, "1.0", new ArrayList<DistributionSetTag>())
.getId());
}
// not exists
assignDS.add(Long.valueOf(100));
@@ -154,14 +154,13 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
@Description("Test verifies that an assignment with automatic cancelation works correctly even if the update is split into multiple partitions on the database.")
public void multiAssigmentHistoryOverMultiplePagesResultsInTwoActiveAction() {
final DistributionSet cancelDs = TestDataUtil.generateDistributionSet("Canceled DS", "1.0", softwareManagement,
distributionSetManagement, new ArrayList<DistributionSetTag>());
final DistributionSet cancelDs = testdataFactory.createDistributionSet("Canceled DS", "1.0",
new ArrayList<DistributionSetTag>());
final DistributionSet cancelDs2 = TestDataUtil.generateDistributionSet("Canceled DS", "1.2", softwareManagement,
distributionSetManagement, new ArrayList<DistributionSetTag>());
final DistributionSet cancelDs2 = testdataFactory.createDistributionSet("Canceled DS", "1.2",
new ArrayList<DistributionSetTag>());
List<Target> targets = targetManagement
.createTargets(TestDataUtil.generateTargets(Constants.MAX_ENTRIES_IN_STATEMENT + 10));
List<Target> targets = testdataFactory.createTargets(Constants.MAX_ENTRIES_IN_STATEMENT + 10);
targets = deploymentManagement.assignDistributionSet(cancelDs, targets).getAssignedEntity();
targets = deploymentManagement.assignDistributionSet(cancelDs2, targets).getAssignedEntity();
@@ -179,15 +178,12 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
+ "also the target goes back to IN_SYNC as no open action is left.")
public void manualCancelWithMultipleAssignmentsCancelLastOneFirst() {
JpaTarget target = new JpaTarget("4712");
final JpaDistributionSet dsFirst = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement, true);
final DistributionSet dsFirst = testdataFactory.createDistributionSet("", true);
dsFirst.setRequiredMigrationStep(true);
final JpaDistributionSet dsSecond = TestDataUtil.generateDistributionSet("2", softwareManagement,
distributionSetManagement, true);
final JpaDistributionSet dsInstalled = TestDataUtil.generateDistributionSet("installed", softwareManagement,
distributionSetManagement, true);
final DistributionSet dsSecond = testdataFactory.createDistributionSet("2", true);
final DistributionSet dsInstalled = testdataFactory.createDistributionSet("installed", true);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet(dsInstalled);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet((JpaDistributionSet) dsInstalled);
target = (JpaTarget) targetManagement.createTarget(target);
// check initial status
@@ -236,15 +232,12 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
+ "also the target goes back to IN_SYNC as no open action is left.")
public void manualCancelWithMultipleAssignmentsCancelMiddleOneFirst() {
JpaTarget target = new JpaTarget("4712");
final JpaDistributionSet dsFirst = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement, true);
final DistributionSet dsFirst = testdataFactory.createDistributionSet("", true);
dsFirst.setRequiredMigrationStep(true);
final JpaDistributionSet dsSecond = TestDataUtil.generateDistributionSet("2", softwareManagement,
distributionSetManagement, true);
final JpaDistributionSet dsInstalled = TestDataUtil.generateDistributionSet("installed", softwareManagement,
distributionSetManagement, true);
final DistributionSet dsSecond = testdataFactory.createDistributionSet("2", true);
final DistributionSet dsInstalled = testdataFactory.createDistributionSet("installed", true);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet(dsInstalled);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet((JpaDistributionSet) dsInstalled);
target = (JpaTarget) targetManagement.createTarget(target);
// check initial status
@@ -295,13 +288,11 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
public void forceQuitSetActionToInactive() throws InterruptedException {
JpaTarget target = new JpaTarget("4712");
final JpaDistributionSet dsInstalled = TestDataUtil.generateDistributionSet("installed", softwareManagement,
distributionSetManagement, true);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet(dsInstalled);
final DistributionSet dsInstalled = testdataFactory.createDistributionSet("installed", true);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet((JpaDistributionSet) dsInstalled);
target = (JpaTarget) targetManagement.createTarget(target);
final JpaDistributionSet ds = TestDataUtil.generateDistributionSet("newDS", softwareManagement,
distributionSetManagement, true);
final DistributionSet ds = testdataFactory.createDistributionSet("newDS", true);
ds.setRequiredMigrationStep(true);
// verify initial status
@@ -336,14 +327,12 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
@Description("Force Quit an not canceled Assignment. Expected behaviour is that the action can not be force quit and there is thrown an exception.")
public void forceQuitNotAllowedThrowsException() {
JpaTarget target = new JpaTarget("4712");
final JpaDistributionSet dsInstalled = TestDataUtil.generateDistributionSet("installed", softwareManagement,
distributionSetManagement, true);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet(dsInstalled);
target = (JpaTarget) targetManagement.createTarget(target);
Target target = new JpaTarget("4712");
final DistributionSet dsInstalled = testdataFactory.createDistributionSet("installed", true);
((JpaTargetInfo) target.getTargetInfo()).setInstalledDistributionSet((JpaDistributionSet) dsInstalled);
target = targetManagement.createTarget(target);
final JpaDistributionSet ds = TestDataUtil.generateDistributionSet("newDS", softwareManagement,
distributionSetManagement, true);
final DistributionSet ds = testdataFactory.createDistributionSet("newDS", true);
ds.setRequiredMigrationStep(true);
// verify initial status
@@ -364,14 +353,16 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
}
}
private Action assignSet(final JpaTarget target, final JpaDistributionSet ds) {
private Action assignSet(final Target target, final DistributionSet ds) {
deploymentManagement.assignDistributionSet(ds.getId(), new String[] { target.getControllerId() });
assertThat(
targetManagement.findTargetByControllerID(target.getControllerId()).getTargetInfo().getUpdateStatus())
.as("wrong update status").isEqualTo(TargetUpdateStatus.PENDING);
assertThat(targetManagement.findTargetByControllerID(target.getControllerId()).getAssignedDistributionSet())
.as("wrong assigned ds").isEqualTo(ds);
final Action action = actionRepository.findByTargetAndDistributionSet(pageReq, target, ds).getContent().get(0);
final Action action = actionRepository
.findByTargetAndDistributionSet(pageReq, (JpaTarget) target, (JpaDistributionSet) ds).getContent()
.get(0);
assertThat(action).as("action should not be null").isNotNull();
return action;
}
@@ -392,14 +383,13 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final String myCtrlIDPref = "myCtrlID";
final Iterable<Target> savedNakedTargets = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(10, myCtrlIDPref, "first description"));
.createTargets(testdataFactory.generateTargets(10, myCtrlIDPref, "first description"));
final String myDeployedCtrlIDPref = "myDeployedCtrlID";
List<Target> savedDeployedTargets = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(20, myDeployedCtrlIDPref, "first description"));
.createTargets(testdataFactory.generateTargets(20, myDeployedCtrlIDPref, "first description"));
final DistributionSet ds = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("");
deploymentManagement.assignDistributionSet(ds, savedDeployedTargets);
@@ -446,7 +436,7 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final EventHandlerMock eventHandlerMock = new EventHandlerMock(0);
eventBus.register(eventHandlerMock);
final List<Target> targets = targetManagement.createTargets(TestDataUtil.generateTargets(10));
final List<Target> targets = testdataFactory.createTargets(10);
final SoftwareModule ah = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(appType, "agent-hub", "1.0.1", null, ""));
@@ -657,7 +647,7 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final DeploymentResult deploymentResult = prepareComplexRepo(undeployedTargetPrefix, noOfUndeployedTargets,
deployedTargetPrefix, noOfDeployedTargets, noOfDistributionSets, "myTestDS");
DistributionSet dsA = TestDataUtil.generateDistributionSet("", softwareManagement, distributionSetManagement);
DistributionSet dsA = testdataFactory.createDistributionSet("");
distributionSetManagement.deleteDistributionSet(dsA.getId());
dsA = distributionSetManagement.findDistributionSetById(dsA.getId());
@@ -761,12 +751,9 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
@Description("Testing if changing target and the status without refreshing the entities from the DB (e.g. concurrent changes from UI and from controller) works")
public void alternatingAssignmentAndAddUpdateActionStatus() {
final JpaDistributionSet dsA = TestDataUtil.generateDistributionSet("a", softwareManagement,
distributionSetManagement);
final JpaDistributionSet dsB = TestDataUtil.generateDistributionSet("b", softwareManagement,
distributionSetManagement);
Target targ = targetManagement
.createTarget(TestDataUtil.buildTargetFixture("target-id-A", "first description"));
final DistributionSet dsA = testdataFactory.createDistributionSet("a");
final DistributionSet dsB = testdataFactory.createDistributionSet("b");
Target targ = targetManagement.createTarget(testdataFactory.generateTarget("target-id-A", "first description"));
List<Target> targs = new ArrayList<>();
targs.add(targ);
@@ -793,7 +780,7 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
assertThat(deploymentManagement.findActiveActionsByTarget(targ).get(0).getDistributionSet())
.as("Installed distribution set of action should be null").isNotNull();
final Page<Action> updAct = actionRepository.findByDistributionSet(pageReq, dsA);
final Page<Action> updAct = actionRepository.findByDistributionSet(pageReq, (JpaDistributionSet) dsA);
final Action action = updAct.getContent().get(0);
action.setStatus(Status.FINISHED);
final ActionStatus statusMessage = new JpaActionStatus((JpaAction) action, Status.FINISHED,
@@ -831,11 +818,9 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
@Description("The test verfies that the DS itself is not changed because of an target assignment"
+ " which is a relationship but not a changed on the entity itself..")
public void checkThatDsRevisionsIsNotChangedWithTargetAssignment() {
final DistributionSet dsA = TestDataUtil.generateDistributionSet("a", softwareManagement,
distributionSetManagement);
TestDataUtil.generateDistributionSet("b", softwareManagement, distributionSetManagement);
Target targ = targetManagement
.createTarget(TestDataUtil.buildTargetFixture("target-id-A", "first description"));
final DistributionSet dsA = testdataFactory.createDistributionSet("a");
testdataFactory.createDistributionSet("b");
Target targ = targetManagement.createTarget(testdataFactory.generateTarget("target-id-A", "first description"));
assertThat(dsA.getOptLockRevision()).as("lock revision is wrong").isEqualTo(
distributionSetManagement.findDistributionSetByIdWithDetails(dsA.getId()).getOptLockRevision());
@@ -854,8 +839,7 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
public void forceSoftAction() {
// prepare
final Target target = targetManagement.createTarget(new JpaTarget("knownControllerId"));
final DistributionSet ds = TestDataUtil.generateDistributionSet("a", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("a");
// assign ds to create an action
final DistributionSetAssignmentResult assignDistributionSet = deploymentManagement.assignDistributionSet(
ds.getId(), ActionType.SOFT, org.eclipse.hawkbit.repository.model.Constants.NO_FORCE_TIME,
@@ -878,8 +862,7 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
public void forceAlreadyForcedActionNothingChanges() {
// prepare
final Target target = targetManagement.createTarget(new JpaTarget("knownControllerId"));
final DistributionSet ds = TestDataUtil.generateDistributionSet("a", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("a");
// assign ds to create an action
final DistributionSetAssignmentResult assignDistributionSet = deploymentManagement.assignDistributionSet(
ds.getId(), ActionType.FORCED, org.eclipse.hawkbit.repository.model.Constants.NO_FORCE_TIME,
@@ -926,14 +909,14 @@ public class DeploymentManagementTest extends AbstractIntegrationTest {
final String deployedTargetPrefix, final int noOfDeployedTargets, final int noOfDistributionSets,
final String distributionSetPrefix) {
final Iterable<Target> nakedTargets = targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(noOfUndeployedTargets, undeployedTargetPrefix, "first description"));
testdataFactory.generateTargets(noOfUndeployedTargets, undeployedTargetPrefix, "first description"));
List<Target> deployedTargets = targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(noOfDeployedTargets, deployedTargetPrefix, "first description"));
testdataFactory.generateTargets(noOfDeployedTargets, deployedTargetPrefix, "first description"));
// creating 10 DistributionSets
final Collection<DistributionSet> dsList = (Collection) TestDataUtil.generateDistributionSets(
distributionSetPrefix, noOfDistributionSets, softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsList = testdataFactory.createDistributionSets(distributionSetPrefix,
noOfDistributionSets);
String time = String.valueOf(System.currentTimeMillis());
time = time.substring(time.length() - 5);

62
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/DistributionSetManagementTest.java
View File

@@ -31,14 +31,15 @@ import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.Action.Status;
import org.eclipse.hawkbit.repository.model.DistributionSetFilter.DistributionSetFilterBuilder;
import org.eclipse.hawkbit.repository.model.ActionStatus;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.DistributionSetFilter.DistributionSetFilterBuilder;
import org.eclipse.hawkbit.repository.model.DistributionSetMetadata;
import org.eclipse.hawkbit.repository.model.DistributionSetTag;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
import org.eclipse.hawkbit.repository.model.SoftwareModule;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.util.WithUser;
import org.fest.assertions.core.Condition;
import org.junit.Test;
import org.springframework.data.domain.Page;
@@ -56,7 +57,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("DistributionSet Management")
public class DistributionSetManagementTest extends AbstractIntegrationTest {
public class DistributionSetManagementTest extends AbstractJpaIntegrationTest {
@Test
@Description("Tests the successfull module update of unused distribution set type which is in fact allowed.")
@@ -178,10 +179,10 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
@Test
@Description("Ensures that it is not possible to create a DS that already exists (unique constraint is on name,version for DS).")
public void createDuplicateDistributionSetsFailsWithException() {
TestDataUtil.generateDistributionSet("a", softwareManagement, distributionSetManagement);
testdataFactory.createDistributionSet("a");
try {
TestDataUtil.generateDistributionSet("a", softwareManagement, distributionSetManagement);
testdataFactory.createDistributionSet("a");
fail("Should not have worked as DS with same UK already exists.");
} catch (final EntityAlreadyExistsException e) {
@@ -239,8 +240,7 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
final String knownKey = "dsMetaKnownKey";
final String knownValue = "dsMetaKnownValue";
final DistributionSet ds = TestDataUtil.generateDistributionSet("testDs", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("testDs");
final DistributionSetMetadata metadata = new JpaDistributionSetMetadata(knownKey, ds, knownValue);
final JpaDistributionSetMetadata createdMetadata = (JpaDistributionSetMetadata) distributionSetManagement
@@ -262,8 +262,7 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
SoftwareModule ah2 = new JpaSoftwareModule(appType, "agent-hub2", "1.0.5", null, "");
SoftwareModule os2 = new JpaSoftwareModule(osType, "poky2", "3.0.3", null, "");
DistributionSet ds = TestDataUtil.generateDistributionSet("ds-1", softwareManagement,
distributionSetManagement);
DistributionSet ds = testdataFactory.createDistributionSet("ds-1");
ah2 = softwareManagement.createSoftwareModule(ah2);
os2 = softwareManagement.createSoftwareModule(os2);
@@ -348,7 +347,7 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
SoftwareModule os2 = new JpaSoftwareModule(osType, "poky2", "3.0.3", null, "");
final SoftwareModule app2 = new JpaSoftwareModule(appType, "app2", "3.0.3", null, "");
DistributionSet ds = TestDataUtil.generateDistributionSet("", softwareManagement, distributionSetManagement);
DistributionSet ds = testdataFactory.createDistributionSet("");
os2 = softwareManagement.createSoftwareModule(os2);
@@ -387,8 +386,7 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
final String knownUpdateValue = "myNewUpdatedValue";
// create a DS
final DistributionSet ds = TestDataUtil.generateDistributionSet("testDs", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("testDs");
// initial opt lock revision must be zero
assertThat(ds.getOptLockRevision()).isEqualTo(1L);
@@ -427,13 +425,12 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
@Description("Tests that a DS queue is possible where the result is ordered by the target assignment, i.e. assigned first in the list.")
public void findDistributionSetsAllOrderedByLinkTarget() {
final List<JpaDistributionSet> buildDistributionSets = TestDataUtil.generateDistributionSets("dsOrder", 10,
softwareManagement, distributionSetManagement);
final List<DistributionSet> buildDistributionSets = testdataFactory.createDistributionSets("dsOrder", 10);
final List<Target> buildTargetFixtures = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(5, "tOrder", "someDesc"));
.createTargets(testdataFactory.generateTargets(5, "tOrder", "someDesc"));
final Iterator<JpaDistributionSet> dsIterator = buildDistributionSets.iterator();
final Iterator<DistributionSet> dsIterator = buildDistributionSets.iterator();
final Iterator<Target> tIterator = buildTargetFixtures.iterator();
final DistributionSet dsFirst = dsIterator.next();
final DistributionSet dsSecond = dsIterator.next();
@@ -482,12 +479,9 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
final DistributionSetTag dsTagD = tagManagement
.createDistributionSetTag(new JpaDistributionSetTag("DistributionSetTag-D"));
Collection<DistributionSet> ds100Group1 = (Collection) TestDataUtil.generateDistributionSets("", 100,
softwareManagement, distributionSetManagement);
Collection<DistributionSet> ds100Group2 = (Collection) TestDataUtil.generateDistributionSets("test2", 100,
softwareManagement, distributionSetManagement);
DistributionSet dsDeleted = TestDataUtil.generateDistributionSet("deleted", softwareManagement,
distributionSetManagement);
Collection<DistributionSet> ds100Group1 = testdataFactory.createDistributionSets("", 100);
Collection<DistributionSet> ds100Group2 = testdataFactory.createDistributionSets("test2", 100);
DistributionSet dsDeleted = testdataFactory.createDistributionSet("deleted");
final DistributionSet dsInComplete = distributionSetManagement
.createDistributionSet(new JpaDistributionSet("notcomplete", "1", "", standardDsType, null));
@@ -498,8 +492,7 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
final DistributionSet dsNewType = distributionSetManagement
.createDistributionSet(new JpaDistributionSet("newtype", "1", "", newType, dsDeleted.getModules()));
deploymentManagement.assignDistributionSet(dsDeleted,
targetManagement.createTargets(Lists.newArrayList(TestDataUtil.generateTargets(5))));
deploymentManagement.assignDistributionSet(dsDeleted, Lists.newArrayList(testdataFactory.createTargets(5)));
distributionSetManagement.deleteDistributionSet(dsDeleted);
dsDeleted = distributionSetManagement.findDistributionSetById(dsDeleted.getId());
@@ -724,7 +717,7 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
@Test
@Description("Simple DS load without the related data that should be loaded lazy.")
public void findDistributionSetsWithoutLazy() {
TestDataUtil.generateDistributionSets(20, softwareManagement, distributionSetManagement);
testdataFactory.createDistributionSets(20);
assertThat(distributionSetManagement.findDistributionSetsByDeletedAndOrCompleted(pageReq, false, true))
.hasSize(20);
@@ -733,10 +726,8 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
@Test
@Description("Deltes a DS that is no in use. Expected behaviour is a hard delete on the database.")
public void deleteUnassignedDistributionSet() {
DistributionSet ds1 = TestDataUtil.generateDistributionSet("ds-1", softwareManagement,
distributionSetManagement);
DistributionSet ds2 = TestDataUtil.generateDistributionSet("ds-2", softwareManagement,
distributionSetManagement);
DistributionSet ds1 = testdataFactory.createDistributionSet("ds-1");
DistributionSet ds2 = testdataFactory.createDistributionSet("ds-2");
ds1 = distributionSetManagement.findDistributionSetByNameAndVersion(ds1.getName(), ds1.getVersion());
ds2 = distributionSetManagement.findDistributionSetByNameAndVersion(ds2.getName(), ds2.getVersion());
@@ -755,10 +746,8 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
@Description("Queries and loads the metadata related to a given software module.")
public void findAllDistributionSetMetadataByDsId() {
// create a DS
DistributionSet ds1 = TestDataUtil.generateDistributionSet("testDs1", softwareManagement,
distributionSetManagement);
DistributionSet ds2 = TestDataUtil.generateDistributionSet("testDs2", softwareManagement,
distributionSetManagement);
DistributionSet ds1 = testdataFactory.createDistributionSet("testDs1");
DistributionSet ds2 = testdataFactory.createDistributionSet("testDs2");
for (int index = 0; index < 10; index++) {
@@ -791,12 +780,9 @@ public class DistributionSetManagementTest extends AbstractIntegrationTest {
@Description("Deltes a DS that is no in use. Expected behaviour is a soft delete on the database, i.e. only marked as "
+ "deleted, kept eas refernce and unavailable for future use..")
public void deleteAssignedDistributionSet() {
DistributionSet ds1 = TestDataUtil.generateDistributionSet("ds-1", softwareManagement,
distributionSetManagement);
DistributionSet ds2 = TestDataUtil.generateDistributionSet("ds-2", softwareManagement,
distributionSetManagement);
DistributionSet dsAssigned = TestDataUtil.generateDistributionSet("ds-3", softwareManagement,
distributionSetManagement);
DistributionSet ds1 = testdataFactory.createDistributionSet("ds-1");
DistributionSet ds2 = testdataFactory.createDistributionSet("ds-2");
DistributionSet dsAssigned = testdataFactory.createDistributionSet("ds-3");
ds1 = distributionSetManagement.findDistributionSetByNameAndVersion(ds1.getName(), ds1.getVersion());
ds2 = distributionSetManagement.findDistributionSetByNameAndVersion(ds2.getName(), ds2.getVersion());

75
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/FreePortFileWriter.java
View File

@@ -1,75 +0,0 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import java.io.File;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
/**
*
*
*/
public class FreePortFileWriter {
private final String filePortPath;
private final int from;
private final int to;
/**
* @param from
* @param to
*/
public FreePortFileWriter(final int from, final int to, final String filePortPath) {
this.from = from;
this.to = to;
this.filePortPath = filePortPath;
}
public int getPort() {
return findFree();
}
protected int findFree() {
for (int i = from; i <= to; i++) {
if (isFree(i)) {
return i;
}
}
throw new RuntimeException("No free port in range " + from + ":" + to);
}
boolean isFree(final int port) {
try {
final File portFile = new File(filePortPath + File.separator + port + ".port");
portFile.getParentFile().mkdirs();
if (portFile.exists()) {
return false;
} else {
boolean isFree = false;
final ServerSocket sock = new ServerSocket();
sock.setReuseAddress(true);
sock.bind(new InetSocketAddress(port));
if (portFile.createNewFile()) {
portFile.deleteOnExit();
isFree = true;
}
sock.close();
// is free:
return isFree;
// We rely on an exception thrown to determine availability or
// not availability.
}
} catch (final Exception e) {
// not free.
return false;
}
}
}

109
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/JpaTestRepositoryManagement.java Normal file
View File

@@ -0,0 +1,109 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import org.eclipse.hawkbit.cache.TenantAwareCacheManager;
import org.eclipse.hawkbit.repository.SystemManagement;
import org.eclipse.hawkbit.repository.util.TestRepositoryManagement;
import org.eclipse.hawkbit.security.SystemSecurityContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.gridfs.GridFsOperations;
import org.springframework.transaction.annotation.Transactional;
public class JpaTestRepositoryManagement implements TestRepositoryManagement {
@PersistenceContext
private EntityManager entityManager;
@Autowired
private TargetRepository targetRepository;
@Autowired
private ActionRepository actionRepository;
@Autowired
private DistributionSetRepository distributionSetRepository;
@Autowired
private SoftwareModuleRepository softwareModuleRepository;
@Autowired
private TenantMetaDataRepository tenantMetaDataRepository;
@Autowired
private DistributionSetTypeRepository distributionSetTypeRepository;
@Autowired
private SoftwareModuleTypeRepository softwareModuleTypeRepository;
@Autowired
private TargetTagRepository targetTagRepository;
@Autowired
private DistributionSetTagRepository distributionSetTagRepository;
@Autowired
private SoftwareModuleMetadataRepository softwareModuleMetadataRepository;
@Autowired
private ActionStatusRepository actionStatusRepository;
@Autowired
private ExternalArtifactRepository externalArtifactRepository;
@Autowired
private LocalArtifactRepository artifactRepository;
@Autowired
private TargetInfoRepository targetInfoRepository;
@Autowired
private GridFsOperations operations;
@Autowired
private RolloutGroupRepository rolloutGroupRepository;
@Autowired
private RolloutRepository rolloutRepository;
@Autowired
private TenantAwareCacheManager cacheManager;
@Autowired
private SystemSecurityContext systemSecurityContext;
@Autowired
private SystemManagement systemManagement;
@Override
public void clearTestRepository() {
deleteAllRepos();
cacheManager.getDirectCacheNames().forEach(name -> cacheManager.getDirectCache(name).clear());
}
@Transactional
public void deleteAllRepos() {
final List<String> tenants = systemSecurityContext.runAsSystem(() -> systemManagement.findTenants());
tenants.forEach(tenant -> {
try {
systemSecurityContext.runAsSystem(() -> {
systemManagement.deleteTenant(tenant);
return null;
});
} catch (final Exception e) {
e.printStackTrace();
}
});
}
}

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

@@ -24,7 +24,6 @@ import org.eclipse.hawkbit.repository.DistributionSetAssignmentResult;
import org.eclipse.hawkbit.repository.ReportManagement;
import org.eclipse.hawkbit.repository.ReportManagement.DateTypes;
import org.eclipse.hawkbit.repository.jpa.model.JpaActionStatus;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetInfo;
import org.eclipse.hawkbit.repository.model.Action;
@@ -38,6 +37,9 @@ import org.eclipse.hawkbit.repository.report.model.DataReportSeries;
import org.eclipse.hawkbit.repository.report.model.DataReportSeriesItem;
import org.eclipse.hawkbit.repository.report.model.InnerOuterDataReportSeries;
import org.eclipse.hawkbit.repository.report.model.SeriesTime;
import org.eclipse.hawkbit.repository.util.TestdataFactory;
import org.eclipse.hawkbit.repository.util.WithSpringAuthorityRule;
import org.eclipse.hawkbit.repository.util.WithUser;
import org.junit.After;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
@@ -55,7 +57,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("Report Management")
public class ReportManagementTest extends AbstractIntegrationTest {
public class ReportManagementTest extends AbstractJpaIntegrationTest {
@Autowired
private ReportManagement reportManagement;
@@ -128,8 +130,7 @@ public class ReportManagementTest extends AbstractIntegrationTest {
final LocalDateTime to = LocalDateTime.now();
final LocalDateTime from = to.minusMonths(maxMonthBackAmountReportTargets);
final DistributionSet distributionSet = TestDataUtil.generateDistributionSet("ds", softwareManagement,
distributionSetManagement);
final DistributionSet distributionSet = testdataFactory.createDistributionSet("ds");
final DynamicDateTimeProvider dynamicDateTimeProvider = new DynamicDateTimeProvider();
auditingHandler.setDateTimeProvider(dynamicDateTimeProvider);
@@ -181,21 +182,18 @@ public class ReportManagementTest extends AbstractIntegrationTest {
final Target knownTarget4 = targetManagement.createTarget(new JpaTarget("t4"));
final Target knownTarget5 = targetManagement.createTarget(new JpaTarget("t5"));
final SoftwareModule ah = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(appType, "agent-hub", "1.0.1", null, ""));
final SoftwareModule jvm = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(runtimeType, "oracle-jre", "1.7.2", null, ""));
final SoftwareModule os = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(osType, "poky", "3.0.2", null, ""));
final SoftwareModule ah = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_APP);
final SoftwareModule jvm = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_RT);
final SoftwareModule os = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_OS);
final DistributionSet distributionSet1 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds1", "0.0.0", standardDsType, os, jvm, ah));
final DistributionSet distributionSet11 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds1", "0.0.1", standardDsType, os, jvm, ah));
final DistributionSet distributionSet2 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds2", "0.0.2", standardDsType, os, jvm, ah));
final DistributionSet distributionSet3 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds3", "0.0.3", standardDsType, os, jvm, ah));
final DistributionSet distributionSet1 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds1", "0.0.0", standardDsType, Lists.newArrayList(os, jvm, ah)));
final DistributionSet distributionSet11 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds1", "0.0.1", standardDsType, Lists.newArrayList(os, jvm, ah)));
final DistributionSet distributionSet2 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds2", "0.0.2", standardDsType, Lists.newArrayList(os, jvm, ah)));
final DistributionSet distributionSet3 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds3", "0.0.3", standardDsType, Lists.newArrayList(os, jvm, ah)));
// ds1(0.0.0)=[target1,target2], ds1(0.0.1)=[target3]
deploymentManagement.assignDistributionSet(distributionSet1.getId(), knownTarget1.getControllerId());
@@ -355,21 +353,18 @@ public class ReportManagementTest extends AbstractIntegrationTest {
final Target knownTarget3 = targetManagement.createTarget(new JpaTarget("t3"));
final Target knownTarget4 = targetManagement.createTarget(new JpaTarget("t4"));
final SoftwareModule ah = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(appType, "agent-hub", "1.0.1", null, ""));
final SoftwareModule jvm = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(runtimeType, "oracle-jre", "1.7.2", null, ""));
final SoftwareModule os = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(osType, "poky", "3.0.2", null, ""));
final SoftwareModule ah = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_APP);
final SoftwareModule jvm = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_RT);
final SoftwareModule os = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_OS);
final DistributionSet distributionSet1 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds1", "0.0.0", standardDsType, os, jvm, ah));
final DistributionSet distributionSet11 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds1", "0.0.1", standardDsType, os, jvm, ah));
final DistributionSet distributionSet2 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds2", "0.0.2", standardDsType, os, jvm, ah));
final DistributionSet distributionSet3 = distributionSetManagement
.createDistributionSet(TestDataUtil.buildDistributionSet("ds3", "0.0.3", standardDsType, os, jvm, ah));
final DistributionSet distributionSet1 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds1", "0.0.0", standardDsType, Lists.newArrayList(os, jvm, ah)));
final DistributionSet distributionSet11 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds1", "0.0.1", standardDsType, Lists.newArrayList(os, jvm, ah)));
final DistributionSet distributionSet2 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds2", "0.0.2", standardDsType, Lists.newArrayList(os, jvm, ah)));
final DistributionSet distributionSet3 = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds3", "0.0.3", standardDsType, Lists.newArrayList(os, jvm, ah)));
// ds1(0.0.0)=[target1,target2], ds1(0.0.1)=[target3]
deploymentManagement.assignDistributionSet(distributionSet1.getId(), knownTarget1.getControllerId());

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

@@ -22,7 +22,6 @@ import org.eclipse.hawkbit.repository.RolloutManagement;
import org.eclipse.hawkbit.repository.jpa.model.JpaAction;
import org.eclipse.hawkbit.repository.jpa.model.JpaActionStatus;
import org.eclipse.hawkbit.repository.jpa.model.JpaRollout;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.jpa.utils.MultipleInvokeHelper;
import org.eclipse.hawkbit.repository.jpa.utils.SuccessCondition;
import org.eclipse.hawkbit.repository.model.Action;
@@ -41,6 +40,7 @@ import org.eclipse.hawkbit.repository.model.SoftwareModule;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.TargetUpdateStatus;
import org.eclipse.hawkbit.repository.model.TotalTargetCountStatus;
import org.eclipse.hawkbit.repository.util.TestdataFactory;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Description;
@@ -49,6 +49,8 @@ import org.springframework.data.domain.Slice;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import com.google.common.collect.Lists;
import ru.yandex.qatools.allure.annotations.Features;
import ru.yandex.qatools.allure.annotations.Stories;
@@ -60,7 +62,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("Rollout Management")
public class RolloutManagementTest extends AbstractIntegrationTest {
public class RolloutManagementTest extends AbstractJpaIntegrationTest {
@Autowired
private RolloutManagement rolloutManagement;
@@ -455,8 +457,7 @@ public class RolloutManagementTest extends AbstractIntegrationTest {
targetToCancel.add(targetList.get(0));
targetToCancel.add(targetList.get(1));
targetToCancel.add(targetList.get(2));
final DistributionSet dsForCancelTest = TestDataUtil.generateDistributionSet("dsForTest", softwareManagement,
distributionSetManagement);
final DistributionSet dsForCancelTest = testdataFactory.createDistributionSet("dsForTest");
deploymentManagement.assignDistributionSet(dsForCancelTest, targetToCancel);
// 5 targets are canceling but still have the status running and 5 are
// still in SCHEDULED
@@ -480,8 +481,7 @@ public class RolloutManagementTest extends AbstractIntegrationTest {
rolloutManagement.startRollout(rolloutOne);
rolloutOne = rolloutManagement.findRolloutById(rolloutOne.getId());
final DistributionSet dsForRolloutTwo = TestDataUtil.generateDistributionSet("dsForRolloutTwo",
softwareManagement, distributionSetManagement);
final DistributionSet dsForRolloutTwo = testdataFactory.createDistributionSet("dsForRolloutTwo");
final Rollout rolloutTwo = createRolloutByVariables("rolloutTwo", "This is the description for rollout two", 1,
"controllerId==rollout-*", dsForRolloutTwo, "50", "80");
@@ -834,7 +834,7 @@ public class RolloutManagementTest extends AbstractIntegrationTest {
Rollout myRollout = createTestRolloutWithTargetsAndDistributionSet(amountTargetsForRollout, amountGroups,
successCondition, errorCondition, rolloutName, rolloutName);
targetManagement.createTargets(TestDataUtil.buildTargetFixtures(amountOtherTargets, "others-", "rollout"));
targetManagement.createTargets(testdataFactory.generateTargets(amountOtherTargets, "others-", "rollout"));
final String rsqlParam = "controllerId==*MyRoll*";
@@ -872,10 +872,9 @@ public class RolloutManagementTest extends AbstractIntegrationTest {
final String errorCondition = "80";
final String rolloutName = "rolloutTest";
final String targetPrefixName = rolloutName;
final DistributionSet distributionSet = TestDataUtil.generateDistributionSet("dsFor" + rolloutName,
softwareManagement, distributionSetManagement);
final DistributionSet distributionSet = testdataFactory.createDistributionSet("dsFor" + rolloutName);
targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(amountTargetsForRollout, targetPrefixName + "-", targetPrefixName));
testdataFactory.generateTargets(amountTargetsForRollout, targetPrefixName + "-", targetPrefixName));
final RolloutGroupConditions conditions = new RolloutGroupConditionBuilder()
.successCondition(RolloutGroupSuccessCondition.THRESHOLD, successCondition)
.errorCondition(RolloutGroupErrorCondition.THRESHOLD, errorCondition)
@@ -933,17 +932,14 @@ public class RolloutManagementTest extends AbstractIntegrationTest {
private Rollout createSimpleTestRolloutWithTargetsAndDistributionSet(final int amountTargetsForRollout,
final int amountOtherTargets, final int groupSize, final String successCondition,
final String errorCondition) {
final SoftwareModule ah = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(appType, "agent-hub", "1.0.1", null, ""));
final SoftwareModule jvm = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(runtimeType, "oracle-jre", "1.7.2", null, ""));
final SoftwareModule os = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(osType, "poky", "3.0.2", null, ""));
final DistributionSet rolloutDS = distributionSetManagement.createDistributionSet(
TestDataUtil.buildDistributionSet("rolloutDS", "0.0.0", standardDsType, os, jvm, ah));
targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(amountTargetsForRollout, "rollout-", "rollout"));
targetManagement.createTargets(TestDataUtil.buildTargetFixtures(amountOtherTargets, "others-", "rollout"));
final SoftwareModule ah = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_APP);
final SoftwareModule jvm = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_RT);
final SoftwareModule os = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_OS);
final DistributionSet rolloutDS = distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("rolloutDS", "0.0.0", standardDsType, Lists.newArrayList(os, jvm, ah)));
targetManagement.createTargets(testdataFactory.generateTargets(amountTargetsForRollout, "rollout-", "rollout"));
targetManagement.createTargets(testdataFactory.generateTargets(amountOtherTargets, "others-", "rollout"));
final String filterQuery = "controllerId==rollout-*";
return createRolloutByVariables("test-rollout-name-1", "test-rollout-description-1", groupSize, filterQuery,
rolloutDS, successCondition, errorCondition);
@@ -952,10 +948,9 @@ public class RolloutManagementTest extends AbstractIntegrationTest {
private Rollout createTestRolloutWithTargetsAndDistributionSet(final int amountTargetsForRollout,
final int groupSize, final String successCondition, final String errorCondition, final String rolloutName,
final String targetPrefixName) {
final DistributionSet dsForRolloutTwo = TestDataUtil.generateDistributionSet("dsFor" + rolloutName,
softwareManagement, distributionSetManagement);
final DistributionSet dsForRolloutTwo = testdataFactory.createDistributionSet("dsFor" + rolloutName);
targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(amountTargetsForRollout, targetPrefixName + "-", targetPrefixName));
testdataFactory.generateTargets(amountTargetsForRollout, targetPrefixName + "-", targetPrefixName));
return createRolloutByVariables(rolloutName, rolloutName + "description", groupSize,
"controllerId==" + targetPrefixName + "-*", dsForRolloutTwo, successCondition, errorCondition);
}

7
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/SoftwareManagementTest.java
View File

@@ -39,6 +39,7 @@ import org.eclipse.hawkbit.repository.model.SoftwareModuleMetadata;
import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.TargetUpdateStatus;
import org.eclipse.hawkbit.repository.util.WithUser;
import org.junit.Test;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
@@ -54,7 +55,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("Software Management")
public class SoftwareManagementTest extends AbstractIntegrationTestWithMongoDB {
public class SoftwareManagementTest extends AbstractJpaIntegrationTestWithMongoDB {
@Test
@Description("Try to update non updatable fields results in repository doing nothing.")
@@ -227,8 +228,8 @@ public class SoftwareManagementTest extends AbstractIntegrationTestWithMongoDB {
final SoftwareModule ah2 = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(appType, "agent-hub", "1.0.2", null, ""));
JpaDistributionSet ds = (JpaDistributionSet) distributionSetManagement.createDistributionSet(
TestDataUtil.buildDistributionSet("ds-1", "1.0.1", standardDsType, os, jvm, ah2));
JpaDistributionSet ds = (JpaDistributionSet) distributionSetManagement.createDistributionSet(testdataFactory
.generateDistributionSet("ds-1", "1.0.1", standardDsType, Lists.newArrayList(os, jvm, ah2)));
final JpaTarget target = (JpaTarget) targetManagement.createTarget(new JpaTarget("test123"));
ds = (JpaDistributionSet) assignSet(target, ds).getDistributionSet();

12
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/SystemManagementTest.java
View File

@@ -18,6 +18,7 @@ import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.report.model.TenantUsage;
import org.eclipse.hawkbit.repository.util.WithSpringAuthorityRule;
import org.junit.Test;
import ru.yandex.qatools.allure.annotations.Description;
@@ -26,7 +27,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("System Management")
public class SystemManagementTest extends AbstractIntegrationTestWithMongoDB {
public class SystemManagementTest extends AbstractJpaIntegrationTestWithMongoDB {
@Test
@Description("Ensures that findTenants returns all tenants and not only restricted to the tenant which currently is logged in")
@@ -108,8 +109,8 @@ public class SystemManagementTest extends AbstractIntegrationTestWithMongoDB {
final List<Target> createdTargets = createTestTargets(targets);
if (updates > 0) {
for (int x = 0; x < updates; x++) {
final DistributionSet ds = TestDataUtil.generateDistributionSet("to be deployed" + x,
softwareManagement, distributionSetManagement, true);
final DistributionSet ds = testdataFactory.createDistributionSet("to be deployed" + x,
true);
deploymentManagement.assignDistributionSet(ds, createdTargets);
}
@@ -125,7 +126,7 @@ public class SystemManagementTest extends AbstractIntegrationTestWithMongoDB {
private List<Target> createTestTargets(final int targets) {
return targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(targets, "testTargetOfTenant", "testTargetOfTenant"));
.createTargets(testdataFactory.generateTargets(targets, "testTargetOfTenant", "testTargetOfTenant"));
}
private void createTestArtifact(final byte[] random) {
@@ -137,8 +138,7 @@ public class SystemManagementTest extends AbstractIntegrationTestWithMongoDB {
}
private void createDeletedTestArtifact(final byte[] random) {
final DistributionSet ds = TestDataUtil.generateDistributionSet("deleted garbage", softwareManagement,
distributionSetManagement, true);
final DistributionSet ds = testdataFactory.createDistributionSet("deleted garbage", true);
ds.getModules().stream().forEach(module -> {
artifactManagement.createLocalArtifact(new ByteArrayInputStream(random), module.getId(), "file1", false);
softwareManagement.deleteSoftwareModule(module);

45
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/TagManagementTest.java
View File

@@ -23,13 +23,13 @@ import org.eclipse.hawkbit.repository.exception.EntityAlreadyExistsException;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetTag;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetTag;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.DistributionSetFilter.DistributionSetFilterBuilder;
import org.eclipse.hawkbit.repository.model.DistributionSetTag;
import org.eclipse.hawkbit.repository.model.DistributionSetTagAssignmentResult;
import org.eclipse.hawkbit.repository.model.Tag;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.TargetTag;
import org.eclipse.hawkbit.repository.model.TargetTagAssignmentResult;
import org.eclipse.hawkbit.repository.model.DistributionSetFilter.DistributionSetFilterBuilder;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.LoggerFactory;
@@ -46,7 +46,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("Tag Management")
public class TagManagementTest extends AbstractIntegrationTest {
public class TagManagementTest extends AbstractJpaIntegrationTest {
public TagManagementTest() {
LOG = LoggerFactory.getLogger(TagManagementTest.class);
}
@@ -59,20 +59,13 @@ public class TagManagementTest extends AbstractIntegrationTest {
@Test
@Description("Full DS tag lifecycle tested. Create tags, assign them to sets and delete the tags.")
public void createAndAssignAndDeleteDistributionSetTags() {
final Collection<DistributionSet> dsAs = (Collection) TestDataUtil.generateDistributionSets("DS-A", 20,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsBs = (Collection) TestDataUtil.generateDistributionSets("DS-B", 10,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsCs = (Collection) TestDataUtil.generateDistributionSets("DS-C", 25,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsABs = (Collection) TestDataUtil.generateDistributionSets("DS-AB", 5,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsACs = (Collection) TestDataUtil.generateDistributionSets("DS-AC", 11,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsBCs = (Collection) TestDataUtil.generateDistributionSets("DS-BC", 13,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsABCs = (Collection) TestDataUtil.generateDistributionSets("DS-ABC", 9,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> dsAs = testdataFactory.createDistributionSets("DS-A", 20);
final Collection<DistributionSet> dsBs = testdataFactory.createDistributionSets("DS-B", 10);
final Collection<DistributionSet> dsCs = testdataFactory.createDistributionSets("DS-C", 25);
final Collection<DistributionSet> dsABs = testdataFactory.createDistributionSets("DS-AB", 5);
final Collection<DistributionSet> dsACs = testdataFactory.createDistributionSets("DS-AC", 11);
final Collection<DistributionSet> dsBCs = testdataFactory.createDistributionSets("DS-BC", 13);
final Collection<DistributionSet> dsABCs = testdataFactory.createDistributionSets("DS-ABC", 9);
final DistributionSetTag tagA = tagManagement.createDistributionSetTag(new JpaDistributionSetTag("A"));
final DistributionSetTag tagB = tagManagement.createDistributionSetTag(new JpaDistributionSetTag("B"));
@@ -169,10 +162,8 @@ public class TagManagementTest extends AbstractIntegrationTest {
@Description("Verifies the toogle mechanism by means on assigning tag if at least on DS in the list does not have"
+ "the tag yet. Unassign if all of them have the tag already.")
public void assignAndUnassignDistributionSetTags() {
final Collection<DistributionSet> groupA = (Collection) TestDataUtil.generateDistributionSets(20,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> groupB = (Collection) TestDataUtil.generateDistributionSets("unassigned", 20,
softwareManagement, distributionSetManagement);
final Collection<DistributionSet> groupA = testdataFactory.createDistributionSets(20);
final Collection<DistributionSet> groupB = testdataFactory.createDistributionSets("unassigned", 20);
final DistributionSetTag tag = tagManagement
.createDistributionSetTag(new JpaDistributionSetTag("tag1", "tagdesc1", ""));
@@ -213,8 +204,8 @@ public class TagManagementTest extends AbstractIntegrationTest {
@Description("Verifies the toogle mechanism by means on assigning tag if at least on target in the list does not have"
+ "the tag yet. Unassign if all of them have the tag already.")
public void assignAndUnassignTargetTags() {
final List<Target> groupA = targetManagement.createTargets(TestDataUtil.generateTargets(20, ""));
final List<Target> groupB = targetManagement.createTargets(TestDataUtil.generateTargets(20, "groupb"));
final List<Target> groupA = targetManagement.createTargets(testdataFactory.generateTargets(20, ""));
final List<Target> groupB = targetManagement.createTargets(testdataFactory.generateTargets(20, "groupb"));
final TargetTag tag = tagManagement.createTargetTag(new JpaTargetTag("tag1", "tagdesc1", ""));
@@ -451,8 +442,8 @@ public class TagManagementTest extends AbstractIntegrationTest {
}
private List<JpaTargetTag> createTargetsWithTags() {
final List<Target> targets = targetManagement.createTargets(TestDataUtil.generateTargets(20));
final Iterable<TargetTag> tags = tagManagement.createTargetTags(TestDataUtil.generateTargetTags(20));
final List<Target> targets = testdataFactory.createTargets(20);
final Iterable<TargetTag> tags = tagManagement.createTargetTags(testdataFactory.generateTargetTags(20));
tags.forEach(tag -> targetManagement.toggleTagAssignment(targets, tag));
@@ -461,10 +452,8 @@ public class TagManagementTest extends AbstractIntegrationTest {
private List<DistributionSetTag> createDsSetsWithTags() {
final Collection<DistributionSet> sets = (Collection) TestDataUtil.generateDistributionSets(20,
softwareManagement, distributionSetManagement);
final Iterable<DistributionSetTag> tags = tagManagement
.createDistributionSetTags(TestDataUtil.generateDistributionSetTags(20));
final Collection<DistributionSet> sets = testdataFactory.createDistributionSets(20);
final Iterable<DistributionSetTag> tags = testdataFactory.createDistributionSetTags(20);
tags.forEach(tag -> distributionSetManagement.toggleTagAssignment(sets, tag));

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

@@ -27,7 +27,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("Target Filter Query Management")
public class TargetFilterQueryManagenmentTest extends AbstractIntegrationTest {
public class TargetFilterQueryManagenmentTest extends AbstractJpaIntegrationTest {
@Test
@Description("Test creation of target filter query.")

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

@@ -44,7 +44,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("Target Management Searches")
public class TargetManagementSearchTest extends AbstractIntegrationTest {
public class TargetManagementSearchTest extends AbstractJpaIntegrationTest {
@Test
@Description("Tests different parameter combinations for target search operations. "
@@ -56,32 +56,30 @@ public class TargetManagementSearchTest extends AbstractIntegrationTest {
final TargetTag targTagZ = tagManagement.createTargetTag(new JpaTargetTag("TargTag-Z"));
final TargetTag targTagW = tagManagement.createTargetTag(new JpaTargetTag("TargTag-W"));
final DistributionSet setA = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement);
final DistributionSet setA = testdataFactory.createDistributionSet("");
final DistributionSet installedSet = TestDataUtil.generateDistributionSet("another", softwareManagement,
distributionSetManagement);
final DistributionSet installedSet = testdataFactory.createDistributionSet("another");
final String targetDsAIdPref = "targ-A";
List<Target> targAs = targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(100, targetDsAIdPref, targetDsAIdPref.concat(" description")));
testdataFactory.generateTargets(100, targetDsAIdPref, targetDsAIdPref.concat(" description")));
targAs = targetManagement.toggleTagAssignment(targAs, targTagX).getAssignedEntity();
final String targetDsBIdPref = "targ-B";
List<Target> targBs = targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(100, targetDsBIdPref, targetDsBIdPref.concat(" description")));
testdataFactory.generateTargets(100, targetDsBIdPref, targetDsBIdPref.concat(" description")));
targBs = targetManagement.toggleTagAssignment(targBs, targTagY).getAssignedEntity();
targBs = targetManagement.toggleTagAssignment(targBs, targTagW).getAssignedEntity();
final String targetDsCIdPref = "targ-C";
List<Target> targCs = targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(100, targetDsCIdPref, targetDsCIdPref.concat(" description")));
testdataFactory.generateTargets(100, targetDsCIdPref, targetDsCIdPref.concat(" description")));
targCs = targetManagement.toggleTagAssignment(targCs, targTagZ).getAssignedEntity();
targCs = targetManagement.toggleTagAssignment(targCs, targTagW).getAssignedEntity();
final String targetDsDIdPref = "targ-D";
final List<Target> targDs = targetManagement.createTargets(
TestDataUtil.buildTargetFixtures(100, targetDsDIdPref, targetDsDIdPref.concat(" description")));
testdataFactory.generateTargets(100, targetDsDIdPref, targetDsDIdPref.concat(" description")));
final String assignedC = targCs.iterator().next().getControllerId();
deploymentManagement.assignDistributionSet(setA.getId(), assignedC);
@@ -680,14 +678,13 @@ public class TargetManagementSearchTest extends AbstractIntegrationTest {
public void targetSearchWithVariousFilterCombinationsAndOrderByDistributionSet() {
final List<Target> notAssigned = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(3, "not", "first description"));
.createTargets(testdataFactory.generateTargets(3, "not", "first description"));
List<Target> targAssigned = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(3, "assigned", "first description"));
.createTargets(testdataFactory.generateTargets(3, "assigned", "first description"));
List<Target> targInstalled = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(3, "installed", "first description"));
.createTargets(testdataFactory.generateTargets(3, "installed", "first description"));
final DistributionSet ds = TestDataUtil.generateDistributionSet("a", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("a");
targAssigned = deploymentManagement.assignDistributionSet(ds, targAssigned).getAssignedEntity();
targInstalled = deploymentManagement.assignDistributionSet(ds, targInstalled).getAssignedEntity();
@@ -714,10 +711,9 @@ public class TargetManagementSearchTest extends AbstractIntegrationTest {
@Test
@Description("Verfies that targets with given assigned DS are returned from repository.")
public void findTargetByAssignedDistributionSet() {
final DistributionSet assignedSet = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement);
targetManagement.createTargets(TestDataUtil.generateTargets(10, "unassigned"));
List<Target> assignedtargets = targetManagement.createTargets(TestDataUtil.generateTargets(10, "assigned"));
final DistributionSet assignedSet = testdataFactory.createDistributionSet("");
targetManagement.createTargets(testdataFactory.generateTargets(10, "unassigned"));
List<Target> assignedtargets = targetManagement.createTargets(testdataFactory.generateTargets(10, "assigned"));
deploymentManagement.assignDistributionSet(assignedSet, assignedtargets);
@@ -734,12 +730,10 @@ public class TargetManagementSearchTest extends AbstractIntegrationTest {
@Test
@Description("Verfies that targets with given installed DS are returned from repository.")
public void findTargetByInstalledDistributionSet() {
final DistributionSet assignedSet = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement);
final DistributionSet installedSet = TestDataUtil.generateDistributionSet("another", softwareManagement,
distributionSetManagement);
targetManagement.createTargets(TestDataUtil.generateTargets(10, "unassigned"));
List<Target> installedtargets = targetManagement.createTargets(TestDataUtil.generateTargets(10, "assigned"));
final DistributionSet assignedSet = testdataFactory.createDistributionSet("");
final DistributionSet installedSet = testdataFactory.createDistributionSet("another");
targetManagement.createTargets(testdataFactory.generateTargets(10, "unassigned"));
List<Target> installedtargets = targetManagement.createTargets(testdataFactory.generateTargets(10, "assigned"));
// set on installed and assign another one
deploymentManagement.assignDistributionSet(installedSet, installedtargets).getActions().forEach(actionId -> {

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

@@ -43,6 +43,8 @@ import org.eclipse.hawkbit.repository.model.Tag;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.TargetIdName;
import org.eclipse.hawkbit.repository.model.TargetTag;
import org.eclipse.hawkbit.repository.util.WithSpringAuthorityRule;
import org.eclipse.hawkbit.repository.util.WithUser;
import org.junit.Test;
import org.springframework.data.domain.PageRequest;
@@ -54,7 +56,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("Target Management")
public class TargetManagementTest extends AbstractIntegrationTest {
public class TargetManagementTest extends AbstractJpaIntegrationTest {
@Test
@Description("Ensures that retrieving the target security is only permitted with the necessary permissions.")
@@ -193,10 +195,8 @@ public class TargetManagementTest extends AbstractIntegrationTest {
@Test
@Description("Finds a target by given ID and checks if all data is in the reponse (including the data defined as lazy).")
public void findTargetByControllerIDWithDetails() {
final DistributionSet set = TestDataUtil.generateDistributionSet("test", softwareManagement,
distributionSetManagement);
final DistributionSet set2 = TestDataUtil.generateDistributionSet("test2", softwareManagement,
distributionSetManagement);
final DistributionSet set = testdataFactory.createDistributionSet("test");
final DistributionSet set2 = testdataFactory.createDistributionSet("test2");
assertThat(targetManagement.countTargetByAssignedDistributionSet(set.getId())).as("Target count is wrong")
.isEqualTo(0);
@@ -248,7 +248,7 @@ public class TargetManagementTest extends AbstractIntegrationTest {
@Test
@Description("Checks if the EntityAlreadyExistsException is thrown if the targets with the same controller ID are created twice.")
public void createMultipleTargetsDuplicate() {
final List<Target> targets = TestDataUtil.buildTargetFixtures(5, "mySimpleTargs", "my simple targets");
final List<Target> targets = testdataFactory.generateTargets(5, "mySimpleTargs", "my simple targets");
targetManagement.createTargets(targets);
try {
targetManagement.createTargets(targets);
@@ -323,7 +323,7 @@ public class TargetManagementTest extends AbstractIntegrationTest {
public void singleTargetIsInsertedIntoRepo() throws Exception {
final String myCtrlID = "myCtrlID";
final Target target = TestDataUtil.buildTargetFixture(myCtrlID, "the description!");
final Target target = testdataFactory.generateTarget(myCtrlID, "the description!");
Target savedTarget = targetManagement.createTarget(target);
assertNotNull("The target should not be null", savedTarget);
@@ -360,9 +360,9 @@ public class TargetManagementTest extends AbstractIntegrationTest {
@Description("Create multiple tragets as bulk operation and delete them in bulk.")
public void bulkTargetCreationAndDelete() throws Exception {
final String myCtrlID = "myCtrlID";
final List<Target> firstList = TestDataUtil.buildTargetFixtures(100, myCtrlID, "first description");
final List<Target> firstList = testdataFactory.generateTargets(100, myCtrlID, "first description");
final Target extra = TestDataUtil.buildTargetFixture("myCtrlID-00081XX", "first description");
final Target extra = testdataFactory.generateTarget("myCtrlID-00081XX", "first description");
List<Target> firstSaved = targetManagement.createTargets(firstList);
@@ -432,7 +432,7 @@ public class TargetManagementTest extends AbstractIntegrationTest {
@Description("Stores target attributes and verfies existence in the repository.")
public void savingTargetControllerAttributes() {
Iterable<Target> ts = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(100, "myCtrlID", "first description"));
.createTargets(testdataFactory.generateTargets(100, "myCtrlID", "first description"));
final Map<String, String> attribs = new HashMap<>();
attribs.put("a.b.c", "abc");
@@ -541,17 +541,17 @@ public class TargetManagementTest extends AbstractIntegrationTest {
@Test
@Description("Tests the assigment of tags to the a single target.")
public void targetTagAssignment() {
Target t1 = TestDataUtil.buildTargetFixture("id-1", "blablub");
Target t1 = testdataFactory.generateTarget("id-1", "blablub");
final int noT2Tags = 4;
final int noT1Tags = 3;
final List<TargetTag> t1Tags = tagManagement
.createTargetTags(TestDataUtil.buildTargetTagFixtures(noT1Tags, "tag1"));
.createTargetTags(testdataFactory.generateTargetTags(noT1Tags, "tag1"));
t1.getTags().addAll(t1Tags);
t1 = targetManagement.createTarget(t1);
Target t2 = TestDataUtil.buildTargetFixture("id-2", "blablub");
Target t2 = testdataFactory.generateTarget("id-2", "blablub");
final List<TargetTag> t2Tags = tagManagement
.createTargetTags(TestDataUtil.buildTargetTagFixtures(noT2Tags, "tag2"));
.createTargetTags(testdataFactory.generateTargetTags(noT2Tags, "tag2"));
t2.getTags().addAll(t2Tags);
t2 = targetManagement.createTarget(t2);
@@ -570,17 +570,17 @@ public class TargetManagementTest extends AbstractIntegrationTest {
@Description("Tests the assigment of tags to multiple targets.")
public void targetTagBulkAssignments() {
final List<Target> tagATargets = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(10, "tagATargets", "first description"));
.createTargets(testdataFactory.generateTargets(10, "tagATargets", "first description"));
final List<Target> tagBTargets = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(10, "tagBTargets", "first description"));
.createTargets(testdataFactory.generateTargets(10, "tagBTargets", "first description"));
final List<Target> tagCTargets = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(10, "tagCTargets", "first description"));
.createTargets(testdataFactory.generateTargets(10, "tagCTargets", "first description"));
final List<Target> tagABTargets = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(10, "tagABTargets", "first description"));
.createTargets(testdataFactory.generateTargets(10, "tagABTargets", "first description"));
final List<Target> tagABCTargets = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(10, "tagABCTargets", "first description"));
.createTargets(testdataFactory.generateTargets(10, "tagABCTargets", "first description"));
final TargetTag tagA = tagManagement.createTargetTag(new JpaTargetTag("A"));
final TargetTag tagB = tagManagement.createTargetTag(new JpaTargetTag("B"));
@@ -645,20 +645,20 @@ public class TargetManagementTest extends AbstractIntegrationTest {
final TargetTag targTagC = tagManagement.createTargetTag(new JpaTargetTag("Targ-C-Tag"));
final List<Target> targAs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(25, "target-id-A", "first description"));
.createTargets(testdataFactory.generateTargets(25, "target-id-A", "first description"));
final List<Target> targBs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(20, "target-id-B", "first description"));
.createTargets(testdataFactory.generateTargets(20, "target-id-B", "first description"));
final List<Target> targCs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(15, "target-id-C", "first description"));
.createTargets(testdataFactory.generateTargets(15, "target-id-C", "first description"));
final List<Target> targABs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(12, "target-id-AB", "first description"));
.createTargets(testdataFactory.generateTargets(12, "target-id-AB", "first description"));
final List<Target> targACs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(13, "target-id-AC", "first description"));
.createTargets(testdataFactory.generateTargets(13, "target-id-AC", "first description"));
final List<Target> targBCs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(7, "target-id-BC", "first description"));
.createTargets(testdataFactory.generateTargets(7, "target-id-BC", "first description"));
final List<Target> targABCs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(17, "target-id-ABC", "first description"));
.createTargets(testdataFactory.generateTargets(17, "target-id-ABC", "first description"));
targetManagement.toggleTagAssignment(targAs, targTagA);
targetManagement.toggleTagAssignment(targABs, targTagA);
@@ -706,7 +706,7 @@ public class TargetManagementTest extends AbstractIntegrationTest {
final TargetTag targTagA = tagManagement.createTargetTag(new JpaTargetTag("Targ-A-Tag"));
final List<Target> targAs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(25, "target-id-A", "first description"));
.createTargets(testdataFactory.generateTargets(25, "target-id-A", "first description"));
targetManagement.toggleTagAssignment(targAs, targTagA);
@@ -726,7 +726,7 @@ public class TargetManagementTest extends AbstractIntegrationTest {
@Description("Test the optimized quere for retrieving all ID/name pairs of targets.")
public void findAllTargetIdNamePaiss() {
final List<Target> targAs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(25, "target-id-A", "first description"));
.createTargets(testdataFactory.generateTargets(25, "target-id-A", "first description"));
final String[] createdTargetIds = targAs.stream().map(t -> t.getControllerId())
.toArray(size -> new String[size]);
@@ -743,10 +743,10 @@ public class TargetManagementTest extends AbstractIntegrationTest {
final TargetTag targTagA = tagManagement.createTargetTag(new JpaTargetTag("Targ-A-Tag"));
final List<Target> targAs = targetManagement
.createTargets(TestDataUtil.buildTargetFixtures(25, "target-id-A", "first description"));
.createTargets(testdataFactory.generateTargets(25, "target-id-A", "first description"));
targetManagement.toggleTagAssignment(targAs, targTagA);
targetManagement.createTargets(TestDataUtil.buildTargetFixtures(25, "target-id-B", "first description"));
targetManagement.createTargets(testdataFactory.generateTargets(25, "target-id-B", "first description"));
final String[] tagNames = null;
final List<Target> targetsListWithNoTag = targetManagement

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

@@ -29,7 +29,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("Tenant Configuration Management")
public class TenantConfigurationManagementTest extends AbstractIntegrationTestWithMongoDB {
public class TenantConfigurationManagementTest extends AbstractJpaIntegrationTestWithMongoDB {
@Test
@Description("Tests that tenant specific configuration can be persisted and in case the tenant does not have specific configuration the default from environment is used instead.")

18
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/TestConfiguration.java
View File

@@ -16,8 +16,8 @@ import org.eclipse.hawkbit.cache.CacheConstants;
import org.eclipse.hawkbit.cache.TenancyCacheManager;
import org.eclipse.hawkbit.cache.TenantAwareCacheManager;
import org.eclipse.hawkbit.repository.jpa.model.helper.EventBusHolder;
import org.eclipse.hawkbit.repository.jpa.utils.RepositoryDataGenerator;
import org.eclipse.hawkbit.repository.jpa.utils.RepositoryDataGenerator.DatabaseCleanupUtil;
import org.eclipse.hawkbit.repository.util.TestRepositoryManagement;
import org.eclipse.hawkbit.repository.util.TestdataFactory;
import org.eclipse.hawkbit.security.DdiSecurityProperties;
import org.eclipse.hawkbit.security.SecurityContextTenantAware;
import org.eclipse.hawkbit.security.SpringSecurityAuditorAware;
@@ -52,14 +52,14 @@ import com.mongodb.MongoClientOptions;
@Profile("test")
public class TestConfiguration implements AsyncConfigurer {
/**
* DB cleanup utility bean is created.
*
* @return the {@link DatabaseCleanupUtil} bean
*/
@Bean
public DatabaseCleanupUtil createDatabaseCleanupUtil() {
return new RepositoryDataGenerator.DatabaseCleanupUtil();
public TestRepositoryManagement testRepositoryManagement() {
return new JpaTestRepositoryManagement();
}
@Bean
public TestdataFactory testdataFactory() {
return new TestdataFactory();
}
@Bean

435
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/TestDataUtil.java
View File

@@ -1,435 +0,0 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import static org.fest.assertions.api.Assertions.assertThat;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import org.apache.commons.io.IOUtils;
import org.eclipse.hawkbit.repository.ArtifactManagement;
import org.eclipse.hawkbit.repository.ControllerManagement;
import org.eclipse.hawkbit.repository.DistributionSetManagement;
import org.eclipse.hawkbit.repository.SoftwareManagement;
import org.eclipse.hawkbit.repository.TargetManagement;
import org.eclipse.hawkbit.repository.jpa.model.AbstractJpaArtifact;
import org.eclipse.hawkbit.repository.jpa.model.JpaActionStatus;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSet;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetTag;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetType;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModuleType;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetTag;
import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.Action.Status;
import org.eclipse.hawkbit.repository.model.ActionStatus;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.DistributionSetTag;
import org.eclipse.hawkbit.repository.model.DistributionSetType;
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.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import net._01001111.text.LoremIpsum;
/**
* Data generator utility for tests.
*
*
*
*/
public class TestDataUtil {
private static final LoremIpsum LOREM = new LoremIpsum();
public static DistributionSet createTestDistributionSet(final SoftwareManagement softwareManagement,
final DistributionSetManagement distributionSetManagement) {
final Pageable pageReq = new PageRequest(0, 400);
DistributionSet set = TestDataUtil.generateDistributionSet("one", softwareManagement,
distributionSetManagement);
set.setVersion("anotherVersion");
set = distributionSetManagement.updateDistributionSet(set);
set.getModules().forEach(module -> {
module.setDescription("updated description");
softwareManagement.updateSoftwareModule(module);
});
// load also lazy stuff
set = distributionSetManagement.findDistributionSetByIdWithDetails(set.getId());
assertThat(distributionSetManagement.findDistributionSetsByDeletedAndOrCompleted(pageReq, false, true)).hasSize(1);
return set;
}
public static List<Target> sendUpdateActionStatusToTargets(final ControllerManagement controllerManagament,
final TargetManagement targetManagement, final ActionRepository actionRepository, final DistributionSet dsA,
final Iterable<Target> targs, final Status status, final String... msgs) {
final List<Target> result = new ArrayList<>();
for (final Target t : targs) {
final List<Action> findByTarget = actionRepository.findByTarget((JpaTarget) t);
for (final Action action : findByTarget) {
result.add(sendUpdateActionStatusToTarget(controllerManagament, targetManagement, status, action, t,
msgs));
}
}
return result;
}
private static Target sendUpdateActionStatusToTarget(final ControllerManagement controllerManagament,
final TargetManagement targetManagement, final Status status, final Action updActA, final Target t,
final String... msgs) {
updActA.setStatus(status);
final ActionStatus statusMessages = new JpaActionStatus();
statusMessages.setAction(updActA);
statusMessages.setOccurredAt(System.currentTimeMillis());
statusMessages.setStatus(status);
for (final String msg : msgs) {
statusMessages.addMessage(msg);
}
controllerManagament.addUpdateActionStatus(statusMessages);
return targetManagement.findTargetByControllerID(t.getControllerId());
}
public static List<JpaDistributionSet> generateDistributionSets(final String suffix, final int number,
final SoftwareManagement softwareManagement, final DistributionSetManagement distributionSetManagement) {
final List<JpaDistributionSet> sets = new ArrayList<>();
for (int i = 0; i < number; i++) {
sets.add(generateDistributionSet(suffix, "v1." + i, softwareManagement, distributionSetManagement, false));
}
return sets;
}
public static DistributionSet generateDistributionSetWithNoSoftwareModules(final String name, final String version,
final DistributionSetManagement distributionSetManagement) {
final DistributionSet dis = new JpaDistributionSet();
dis.setName(name);
dis.setVersion(version);
dis.setDescription("Test describtion for " + name);
return distributionSetManagement.createDistributionSet(dis);
}
public static List<JpaDistributionSet> generateDistributionSets(final int number,
final SoftwareManagement softwareManagement, final DistributionSetManagement distributionSetManagement) {
return generateDistributionSets("", number, softwareManagement, distributionSetManagement);
}
public static JpaDistributionSet generateDistributionSet(final String suffix, final String version,
final SoftwareManagement softwareManagement, final DistributionSetManagement distributionSetManagement,
final boolean isRequiredMigrationStep) {
final SoftwareModule ah = softwareManagement.createSoftwareModule(new JpaSoftwareModule(
findOrCreateSoftwareModuleType(softwareManagement, "application"), suffix + "application",
version + "." + new Random().nextInt(100), LOREM.words(20), suffix + " vendor Limited, California"));
final SoftwareModule jvm = softwareManagement.createSoftwareModule(
new JpaSoftwareModule(findOrCreateSoftwareModuleType(softwareManagement, "runtime"),
suffix + "app runtime", version + "." + new Random().nextInt(100), LOREM.words(20),
suffix + " vendor GmbH, Stuttgart, Germany"));
final SoftwareModule os = softwareManagement
.createSoftwareModule(new JpaSoftwareModule(findOrCreateSoftwareModuleType(softwareManagement, "os"),
suffix + " Firmware", version + "." + new Random().nextInt(100), LOREM.words(20),
suffix + " vendor Limited Inc, California"));
final List<SoftwareModuleType> mand = new ArrayList<>();
mand.add(findOrCreateSoftwareModuleType(softwareManagement, "os"));
final List<SoftwareModuleType> opt = new ArrayList<>();
opt.add(findOrCreateSoftwareModuleType(softwareManagement, "application"));
opt.add(findOrCreateSoftwareModuleType(softwareManagement, "runtime"));
return (JpaDistributionSet) distributionSetManagement.createDistributionSet(
buildDistributionSet(suffix != null && suffix.length() > 0 ? suffix : "DS", version,
findOrCreateDistributionSetType(distributionSetManagement, "ecl_os_app_jvm",
"OS mandatory App/JVM optional", mand, opt),
os, jvm, ah).setRequiredMigrationStep(isRequiredMigrationStep));
}
public static DistributionSet generateDistributionSet(final String suffix, final String version,
final SoftwareManagement softwareManagement, final DistributionSetManagement distributionSetManagement,
final Collection<DistributionSetTag> tags) {
final DistributionSet set = generateDistributionSet(suffix, version, softwareManagement,
distributionSetManagement, false);
final List<DistributionSet> sets = new ArrayList<DistributionSet>();
sets.add(set);
tags.forEach(tag -> distributionSetManagement.toggleTagAssignment(sets, tag));
return distributionSetManagement.findDistributionSetById(set.getId());
}
public static List<Target> generateTargets(final int number) {
return generateTargets(0, number, "Test target ");
}
public static List<Target> generateTargets(final int number, final String prefix) {
return generateTargets(0, number, prefix);
}
public static List<Target> generateTargets(final int start, final int number, final String prefix) {
final List<Target> targets = new ArrayList<>();
for (int i = start; i < start + number; i++) {
targets.add(new JpaTarget(prefix + i));
}
return targets;
}
public static List<TargetTag> generateTargetTags(final int number) {
final List<TargetTag> result = new ArrayList<>();
for (int i = 0; i < number; i++) {
result.add(new JpaTargetTag("tag" + i, "tagdesc" + i, "" + i));
}
return result;
}
public static List<DistributionSetTag> generateDistributionSetTags(final int number) {
final List<DistributionSetTag> result = new ArrayList<>();
for (int i = 0; i < number; i++) {
result.add(new JpaDistributionSetTag("tag" + i, "tagdesc" + i, "" + i));
}
return result;
}
public static JpaDistributionSet generateDistributionSet(final String suffix,
final SoftwareManagement softwareManagement, final DistributionSetManagement distributionSetManagement,
final boolean isRequiredMigrationStep) {
return generateDistributionSet(suffix, "v1.0", softwareManagement, distributionSetManagement,
isRequiredMigrationStep);
}
public static JpaDistributionSet generateDistributionSet(final String suffix,
final SoftwareManagement softwareManagement, final DistributionSetManagement distributionSetManagement) {
return generateDistributionSet(suffix, "v1.0", softwareManagement, distributionSetManagement, false);
}
public static List<AbstractJpaArtifact> generateArtifacts(final ArtifactManagement artifactManagement,
final Long moduleId) {
final List<AbstractJpaArtifact> artifacts = new ArrayList<>();
for (int i = 0; i < 3; i++) {
final InputStream stubInputStream = IOUtils.toInputStream("some test data" + i);
artifacts.add((AbstractJpaArtifact) artifactManagement.createLocalArtifact(stubInputStream, moduleId,
"filename" + i, false));
}
return artifacts;
}
public static Target createTarget(final TargetManagement targetManagement) {
final String targetExist = "targetExist";
final Target target = new JpaTarget(targetExist);
targetManagement.createTarget(target);
return target;
}
public static DistributionSet generateDistributionSet(final String suffix,
final SoftwareManagement softwareManagement, final DistributionSetManagement distributionSetManagement,
final Collection<DistributionSetTag> tags) {
return generateDistributionSet(suffix, "v1.0", softwareManagement, distributionSetManagement, tags);
}
public static SoftwareModuleType findOrCreateSoftwareModuleType(final SoftwareManagement softwareManagement,
final String softwareModuleType) {
final SoftwareModuleType findSoftwareModuleTypeByKey = softwareManagement
.findSoftwareModuleTypeByKey(softwareModuleType);
if (findSoftwareModuleTypeByKey != null) {
return findSoftwareModuleTypeByKey;
}
return softwareManagement.createSoftwareModuleType(new JpaSoftwareModuleType(softwareModuleType,
softwareModuleType, "Standard type " + softwareManagement, 1));
}
public static DistributionSetType findOrCreateDistributionSetType(
final DistributionSetManagement distributionSetManagement, final String dsTypeKey, final String dsTypeName,
final Collection<SoftwareModuleType> mandatory, final Collection<SoftwareModuleType> optional) {
final DistributionSetType findDistributionSetTypeByname = distributionSetManagement
.findDistributionSetTypeByKey(dsTypeKey);
if (findDistributionSetTypeByname != null) {
return findDistributionSetTypeByname;
}
final DistributionSetType type = new JpaDistributionSetType(dsTypeKey, dsTypeName,
"Standard type" + dsTypeName);
mandatory.forEach(entry -> type.addMandatoryModuleType(entry));
optional.forEach(entry -> type.addOptionalModuleType(entry));
return distributionSetManagement.createDistributionSetType(type);
}
/**
* builds a set of {@link Target} fixtures from the given parameters.
*
* @param noOfTgts
* number of targets to create
* @param ctlrIDPrefix
* prefix used for the controller ID
* @param descriptionPrefix
* prefix used for the description
* @return set of {@link Target}
*/
public static List<Target> buildTargetFixtures(final int noOfTgts, final String ctlrIDPrefix,
final String descriptionPrefix) {
return buildTargetFixtures(noOfTgts, ctlrIDPrefix, descriptionPrefix, null);
}
/**
* method creates set of targets by by generating the controller ID and the
* description like: prefix + no of target.
*
* @param noOfTgts
* number of targets which should be created
* @param ctlrIDPrefix
* prefix of the controllerID which is concatenated with the
* number of the target
* @param descriptionPrefix
* prefix of the target description which is concatenated with
* the number of the target
* @param tags
* tags which should be added to the created {@link Target}s
* @return set of created targets
*/
public static List<Target> buildTargetFixtures(final int noOfTgts, final String ctlrIDPrefix,
final String descriptionPrefix, final TargetTag[] tags) {
final List<Target> list = new ArrayList<Target>();
for (int i = 0; i < noOfTgts; i++) {
String ctrlID = ctlrIDPrefix;
if (Strings.isNullOrEmpty(ctrlID)) {
ctrlID = UUID.randomUUID().toString();
}
ctrlID = String.format("%s-%05d", ctrlID, i);
final String description = String.format("the description of ProvisioningTarget: [%s]", ctrlID);
final Target target = buildTargetFixture(ctrlID, description, tags);
list.add(target);
}
return list;
}
/**
* builds a single {@link Target} fixture from the given parameters.
*
* @param ctrlID
* controllerID
* @param description
* the description of the target
* @param tags
* assigned {@link TargetTag}s
* @return the created {@link Target}
*/
public static Target buildTargetFixture(final String ctrlID, final String description, final TargetTag[] tags) {
final Target target = new JpaTarget(ctrlID);
target.setName("Prov.Target ".concat(ctrlID));
target.setDescription(description);
if (tags != null && tags.length > 0) {
for (final TargetTag t : tags) {
target.getTags().add(t);
}
}
return target;
}
/**
* builder method for creating a single target object.
*
* @param ctrlID
* the ID of the target
* @param description
* of the target
* @return the created target object
*/
public static Target buildTargetFixture(final String ctrlID, final String description) {
return buildTargetFixture(ctrlID, description, null);
}
/**
* builder method for creating a {@link DistributionSet}.
*
* @param name
* of the DS
* @param version
* of the DS
* @param os
* operating system of the DS
* @param jvm
* java virtual machine of the DS
* @param agentHub
* of the DS
* @return the created {@link DistributionSet}
*/
public static DistributionSet buildDistributionSet(final String name, final String version,
final DistributionSetType type, final SoftwareModule os, final SoftwareModule jvm,
final SoftwareModule agentHub) {
final DistributionSet distributionSet = new JpaDistributionSet(name, version, null, type,
Lists.newArrayList(os, jvm, agentHub));
distributionSet.setDescription(
String.format("description of DistributionSet; name = '%s', version = '%s'", name, version));
return distributionSet;
}
/**
* builder method for creating a set of {@link TargetTag}.
*
* @param noOfTags
* number of {@link TargetTag}. to be created
* @param tagPrefix
* prefix for the {@link TargetTag.getName()}
* @return the created set of {@link TargetTag}s
*/
public static List<TargetTag> buildTargetTagFixtures(final int noOfTags, final String tagPrefix) {
final List<TargetTag> list = new ArrayList<>();
for (int i = 0; i < noOfTags; i++) {
String tagName = "myTag";
if (!Strings.isNullOrEmpty(tagPrefix)) {
tagName = tagPrefix;
}
tagName = String.format("%s-%05d", tagName, i);
final TargetTag targetTag = buildTargetTagFixture(tagName);
list.add(targetTag);
}
return list;
}
/**
* builder method for creating a simple {@link TargetTag}.
*
* @param tagName
* name of the Tag
* @return the {@link TargetTag}
*/
public static TargetTag buildTargetTagFixture(final String tagName) {
return new JpaTargetTag(tagName);
}
}

278
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/WithSpringAuthorityRule.java
View File

@@ -1,278 +0,0 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import org.eclipse.hawkbit.im.authentication.SpPermission;
import org.eclipse.hawkbit.im.authentication.TenantAwareAuthenticationDetails;
import org.eclipse.hawkbit.repository.jpa.model.helper.SystemManagementHolder;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
import org.springframework.security.authentication.TestingAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
public class WithSpringAuthorityRule implements TestRule {
/*
* (non-Javadoc)
*
* @see org.junit.rules.TestRule#apply(org.junit.runners.model.Statement,
* org.junit.runner.Description)
*/
@Override
public Statement apply(final Statement base, final Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
final SecurityContext oldContext = before(description);
try {
base.evaluate();
} finally {
after(oldContext);
}
}
};
}
private SecurityContext before(final Description description) throws Throwable {
final SecurityContext oldContext = SecurityContextHolder.getContext();
WithUser annotation = description.getAnnotation(WithUser.class);
if (annotation == null) {
annotation = description.getTestClass().getAnnotation(WithUser.class);
}
if (annotation != null) {
setSecurityContext(annotation);
if (annotation.autoCreateTenant()) {
SystemManagementHolder.getInstance().getSystemManagement().getTenantMetadata(annotation.tenantId());
}
}
return oldContext;
}
/**
* @param annotation
*/
private void setSecurityContext(final WithUser annotation) {
SecurityContextHolder.setContext(new SecurityContext() {
/**
*
*/
private static final long serialVersionUID = 1L;
@Override
public void setAuthentication(final Authentication authentication) {
}
@Override
public Authentication getAuthentication() {
final String[] authorities;
if (annotation.allSpPermissions()) {
authorities = getAllAuthorities(annotation.authorities(), annotation.removeFromAllPermission());
} else {
authorities = annotation.authorities();
}
final TestingAuthenticationToken testingAuthenticationToken = new TestingAuthenticationToken(
annotation.principal(), annotation.credentials(), authorities);
testingAuthenticationToken
.setDetails(new TenantAwareAuthenticationDetails(annotation.tenantId(), false));
return testingAuthenticationToken;
}
private String[] getAllAuthorities(final String[] additionalAuthorities, final String[] notInclude) {
final List<String> allPermissions = new ArrayList<>();
final Field[] declaredFields = SpPermission.class.getDeclaredFields();
for (final Field field : declaredFields) {
if (Modifier.isPublic(field.getModifiers()) && Modifier.isStatic(field.getModifiers())) {
field.setAccessible(true);
try {
boolean addPermission = true;
final String permissionName = (String) field.get(null);
if (notInclude != null) {
for (final String notInlcudePerm : notInclude) {
if (permissionName.equals(notInlcudePerm)) {
addPermission = false;
break;
}
}
}
if (addPermission) {
allPermissions.add(permissionName);
}
} catch (IllegalArgumentException | IllegalAccessException e) {
// nope
}
}
}
for (final String authority : additionalAuthorities) {
allPermissions.add(authority);
}
return allPermissions.toArray(new String[allPermissions.size()]);
}
});
}
private void after(final SecurityContext oldContext) {
SecurityContextHolder.setContext(oldContext);
}
/**
* @param callable
* @return
* @throws Exception
*/
public <T> T runAsPrivileged(final Callable<T> callable) throws Exception {
return runAs(privilegedUser(), callable);
}
/**
*
* @param withUser
* @param callable
* @return
* @throws Exception
*/
public <T> T runAs(final WithUser withUser, final Callable<T> callable) throws Exception {
final SecurityContext oldContext = SecurityContextHolder.getContext();
setSecurityContext(withUser);
if (withUser.autoCreateTenant()) {
SystemManagementHolder.getInstance().getSystemManagement().getTenantMetadata(withUser.tenantId());
}
try {
return callable.call();
} finally {
after(oldContext);
}
}
public static WithUser withUser(final String principal, final String... authorities) {
return withUserAndTenant(principal, "default", true, true, authorities);
}
public static WithUser withUser(final String principal, final boolean allSpPermision, final String... authorities) {
return withUserAndTenant(principal, "default", true, allSpPermision, authorities);
}
public static WithUser withUser(final boolean autoCreateTenant) {
return withUserAndTenant("bumlux", "default", autoCreateTenant, true, new String[] {});
}
public static WithUser withUserAndTenant(final String principal, final String tenant, final String... authorities) {
return withUserAndTenant(principal, tenant, true, true, new String[] {});
}
public static WithUser withUserAndTenant(final String principal, final String tenant,
final boolean autoCreateTenant, final boolean allSpPermission, final String... authorities) {
return new WithUser() {
@Override
public Class<? extends Annotation> annotationType() {
return WithUser.class;
}
@Override
public String principal() {
return principal;
}
@Override
public String credentials() {
return null;
}
@Override
public String[] authorities() {
return authorities;
}
@Override
public boolean allSpPermissions() {
return allSpPermission;
}
@Override
public String[] removeFromAllPermission() {
return null;
}
@Override
public String tenantId() {
return tenant;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.hawkbit.WithUser#autoCreateTenant()
*/
@Override
public boolean autoCreateTenant() {
return autoCreateTenant;
}
};
}
private static WithUser privilegedUser() {
return new WithUser() {
@Override
public Class<? extends Annotation> annotationType() {
return WithUser.class;
}
@Override
public String principal() {
return "bumlux";
}
@Override
public String credentials() {
return null;
}
@Override
public String[] authorities() {
return new String[] { "ROLE_CONTROLLER" };
}
@Override
public boolean allSpPermissions() {
return true;
}
@Override
public String[] removeFromAllPermission() {
return null;
}
@Override
public String tenantId() {
return "default";
}
/*
* (non-Javadoc)
*
* @see org.eclipse.hawkbit.WithUser#autoCreateTenant()
*/
@Override
public boolean autoCreateTenant() {
return true;
}
};
}
}

77
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/WithUser.java
View File

@@ -1,77 +0,0 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Annotation to run test classes or test methods with a specific user with
* specific permissions.
*
*
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD, ElementType.TYPE })
@Inherited
public @interface WithUser {
/**
* Gets the test principal.
*
* @return test principal
*/
String principal() default "TestPrincipal";
/**
* Gets the test credentials.
*
* @return test credentials
*/
String credentials() default "TestCredentials";
/**
* Gets the test tenant id.
*
* @return test tenant id
*/
String tenantId() default "default";
/**
* Should tenant auto created.
*
* @return <true> = auto create <false> not create
*/
boolean autoCreateTenant() default true;
/**
* Gets the test authorities.
*
* @return authorities
*/
String[] authorities() default {};
/**
* Gets the test all permissions.
*
* @return permissions
*/
boolean allSpPermissions() default false;
/**
* Gets the test removeFromAllPermission.
*
* @return removeFromAllPermission
*/
String[] removeFromAllPermission() default {};
}

4
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/model/ModelEqualsHashcodeTest.java
View File

@@ -10,7 +10,7 @@ package org.eclipse.hawkbit.repository.jpa.model;
import static org.fest.assertions.api.Assertions.assertThat;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
import org.junit.Test;
@@ -20,7 +20,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Unit Tests - Repository")
@Stories("Repository Model")
public class ModelEqualsHashcodeTest extends AbstractIntegrationTest {
public class ModelEqualsHashcodeTest extends AbstractJpaIntegrationTest {
@Test
@Description("Verfies that different objects even with identical primary key, version and tenant "

4
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLActionFieldsTest.java
View File

@@ -13,7 +13,7 @@ import static org.junit.Assert.fail;
import org.eclipse.hawkbit.repository.ActionFields;
import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaAction;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
import org.eclipse.hawkbit.repository.model.Action;
@@ -30,7 +30,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter actions")
public class RSQLActionFieldsTest extends AbstractIntegrationTest {
public class RSQLActionFieldsTest extends AbstractJpaIntegrationTest {
private Target target;
private JpaAction action;

27
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLDistributionSetFieldTest.java
View File

@@ -15,12 +15,12 @@ import java.util.Arrays;
import org.eclipse.hawkbit.repository.DistributionSetFields;
import org.eclipse.hawkbit.repository.exception.RSQLParameterSyntaxException;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.TestDataUtil;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetMetadata;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetTag;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.DistributionSetTag;
import org.eclipse.hawkbit.repository.util.TestdataFactory;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.domain.Page;
@@ -32,19 +32,18 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter distribution set")
public class RSQLDistributionSetFieldTest extends AbstractIntegrationTest {
public class RSQLDistributionSetFieldTest extends AbstractJpaIntegrationTest {
@Before
public void seuptBeforeTest() {
DistributionSet ds = TestDataUtil.generateDistributionSet("DS", softwareManagement, distributionSetManagement);
DistributionSet ds = testdataFactory.createDistributionSet("DS");
ds.setDescription("DS");
ds = distributionSetManagement.updateDistributionSet(ds);
distributionSetManagement
.createDistributionSetMetadata(new JpaDistributionSetMetadata("metaKey", ds, "metaValue"));
DistributionSet ds2 = TestDataUtil
.generateDistributionSets("NewDS", 3, softwareManagement, distributionSetManagement).get(0);
DistributionSet ds2 = testdataFactory.createDistributionSets("NewDS", 3).get(0);
ds2.setDescription("DS%");
ds2 = distributionSetManagement.updateDistributionSet(ds2);
@@ -89,10 +88,12 @@ public class RSQLDistributionSetFieldTest extends AbstractIntegrationTest {
@Test
@Description("Test filter distribution set by version")
public void testFilterByParameterVersion() {
assertRSQLQuery(DistributionSetFields.VERSION.name() + "==v1.0", 2);
assertRSQLQuery(DistributionSetFields.VERSION.name() + "!=v1.0", 2);
assertRSQLQuery(DistributionSetFields.VERSION.name() + "=in=(v1.0,v1.1)", 3);
assertRSQLQuery(DistributionSetFields.VERSION.name() + "=out=(v1.0,error)", 2);
assertRSQLQuery(DistributionSetFields.VERSION.name() + "==" + TestdataFactory.DEFAULT_VERSION, 1);
assertRSQLQuery(DistributionSetFields.VERSION.name() + "!=" + TestdataFactory.DEFAULT_VERSION, 3);
assertRSQLQuery(
DistributionSetFields.VERSION.name() + "=in=(" + TestdataFactory.DEFAULT_VERSION + ",1.0.0,1.0.1)", 3);
assertRSQLQuery(DistributionSetFields.VERSION.name() + "=out=(" + TestdataFactory.DEFAULT_VERSION + ",error)",
3);
}
@Test
@@ -121,10 +122,10 @@ public class RSQLDistributionSetFieldTest extends AbstractIntegrationTest {
@Test
@Description("Test filter distribution set by type")
public void testFilterByType() {
assertRSQLQuery(DistributionSetFields.TYPE.name() + "==ecl_os_app_jvm", 4);
assertRSQLQuery(DistributionSetFields.TYPE.name() + "==" + TestdataFactory.DS_TYPE_DEFAULT, 4);
assertRSQLQuery(DistributionSetFields.TYPE.name() + "==noExist*", 0);
assertRSQLQuery(DistributionSetFields.TYPE.name() + "=in=(ecl_os_app_jvm,ecl)", 4);
assertRSQLQuery(DistributionSetFields.TYPE.name() + "=out=(ecl_os_app_jvm)", 0);
assertRSQLQuery(DistributionSetFields.TYPE.name() + "=in=(" + TestdataFactory.DS_TYPE_DEFAULT + ",ecl)", 4);
assertRSQLQuery(DistributionSetFields.TYPE.name() + "=out=(" + TestdataFactory.DS_TYPE_DEFAULT + ")", 0);
}
@Test

8
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLDistributionSetMetadataFieldsTest.java
View File

@@ -14,8 +14,7 @@ import java.util.ArrayList;
import java.util.List;
import org.eclipse.hawkbit.repository.DistributionSetMetadataFields;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.TestDataUtil;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetMetadata;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.DistributionSetMetadata;
@@ -30,14 +29,13 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter distribution set metadata")
public class RSQLDistributionSetMetadataFieldsTest extends AbstractIntegrationTest {
public class RSQLDistributionSetMetadataFieldsTest extends AbstractJpaIntegrationTest {
private Long distributionSetId;
@Before
public void setupBeforeTest() {
final DistributionSet distributionSet = TestDataUtil.generateDistributionSet("DS", softwareManagement,
distributionSetManagement);
final DistributionSet distributionSet = testdataFactory.createDistributionSet("DS");
distributionSetId = distributionSet.getId();
final List<DistributionSetMetadata> metadata = new ArrayList<>();

10
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLRolloutGroupFields.java
View File

@@ -11,8 +11,7 @@ package org.eclipse.hawkbit.repository.jpa.rsql;
import static org.fest.assertions.api.Assertions.assertThat;
import org.eclipse.hawkbit.repository.RolloutGroupFields;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.TestDataUtil;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaRollout;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.Rollout;
@@ -30,7 +29,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter rollout group")
public class RSQLRolloutGroupFields extends AbstractIntegrationTest {
public class RSQLRolloutGroupFields extends AbstractJpaIntegrationTest {
private Long rolloutGroupId;
private Rollout rollout;
@@ -38,9 +37,8 @@ public class RSQLRolloutGroupFields extends AbstractIntegrationTest {
@Before
public void seuptBeforeTest() {
final int amountTargets = 20;
targetManagement.createTargets(TestDataUtil.buildTargetFixtures(amountTargets, "rollout", "rollout"));
final DistributionSet dsA = TestDataUtil.generateDistributionSet("", softwareManagement,
distributionSetManagement);
targetManagement.createTargets(testdataFactory.generateTargets(amountTargets, "rollout", "rollout"));
final DistributionSet dsA = testdataFactory.createDistributionSet("");
rollout = createRollout("rollout1", 4, dsA.getId(), "controllerId==rollout*");
rollout = rolloutManagement.findRolloutById(rollout.getId());
this.rolloutGroupId = rollout.getRolloutGroups().get(0).getId();

4
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLSoftwareModuleFieldTest.java
View File

@@ -11,7 +11,7 @@ package org.eclipse.hawkbit.repository.jpa.rsql;
import static org.fest.assertions.api.Assertions.assertThat;
import org.eclipse.hawkbit.repository.SoftwareModuleFields;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModuleMetadata;
import org.eclipse.hawkbit.repository.model.SoftwareModule;
@@ -27,7 +27,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter software module")
public class RSQLSoftwareModuleFieldTest extends AbstractIntegrationTest {
public class RSQLSoftwareModuleFieldTest extends AbstractJpaIntegrationTest {
@Before
public void setupBeforeTest() {

12
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLSoftwareModuleMetadataFieldsTest.java
View File

@@ -14,12 +14,11 @@ import java.util.ArrayList;
import java.util.List;
import org.eclipse.hawkbit.repository.SoftwareModuleMetadataFields;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.TestDataUtil;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModuleMetadata;
import org.eclipse.hawkbit.repository.model.SoftwareModule;
import org.eclipse.hawkbit.repository.model.SoftwareModuleMetadata;
import org.eclipse.hawkbit.repository.util.TestdataFactory;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.domain.Page;
@@ -31,15 +30,14 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter software module metadata")
public class RSQLSoftwareModuleMetadataFieldsTest extends AbstractIntegrationTest {
public class RSQLSoftwareModuleMetadataFieldsTest extends AbstractJpaIntegrationTest {
private Long softwareModuleId;
@Before
public void setupBeforeTest() {
final SoftwareModule softwareModule = softwareManagement.createSoftwareModule(
new JpaSoftwareModule(TestDataUtil.findOrCreateSoftwareModuleType(softwareManagement, "application"),
"application", "1.0.0", "Desc", "vendor Limited, California"));
final SoftwareModule softwareModule = testdataFactory.createSoftwareModule(TestdataFactory.SM_TYPE_APP);
softwareModuleId = softwareModule.getId();
final List<SoftwareModuleMetadata> metadata = new ArrayList<>();

8
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLSoftwareModuleTypeFieldsTest.java
View File

@@ -11,7 +11,7 @@ package org.eclipse.hawkbit.repository.jpa.rsql;
import static org.fest.assertions.api.Assertions.assertThat;
import org.eclipse.hawkbit.repository.SoftwareModuleTypeFields;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.model.SoftwareModuleType;
import org.junit.Test;
import org.springframework.data.domain.Page;
@@ -23,7 +23,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter software module test type")
public class RSQLSoftwareModuleTypeFieldsTest extends AbstractIntegrationTest {
public class RSQLSoftwareModuleTypeFieldsTest extends AbstractJpaIntegrationTest {
@Test
@Description("Test filter software module test type by id")
@@ -34,7 +34,7 @@ public class RSQLSoftwareModuleTypeFieldsTest extends AbstractIntegrationTest {
@Test
@Description("Test filter software module test type by name")
public void testFilterByParameterName() {
assertRSQLQuery(SoftwareModuleTypeFields.NAME.name() + "==ECL*", 3);
assertRSQLQuery(SoftwareModuleTypeFields.NAME.name() + "==Firmware", 1);
}
@Test
@@ -55,7 +55,7 @@ public class RSQLSoftwareModuleTypeFieldsTest extends AbstractIntegrationTest {
@Test
@Description("Test filter software module test type by max")
public void testFilterByMaxAssignment() {
assertRSQLQuery(SoftwareModuleTypeFields.MAXASSIGNMENTS.name() + "==1", 3);
assertRSQLQuery(SoftwareModuleTypeFields.MAXASSIGNMENTS.name() + "==1", 2);
}
private void assertRSQLQuery(final String rsqlParam, final long excpectedEntity) {

4
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLTagFieldsTest.java
View File

@@ -11,7 +11,7 @@ package org.eclipse.hawkbit.repository.jpa.rsql;
import static org.fest.assertions.api.Assertions.assertThat;
import org.eclipse.hawkbit.repository.TagFields;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetTag;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetTag;
import org.eclipse.hawkbit.repository.model.DistributionSetTag;
@@ -27,7 +27,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter target and distribution set tags")
public class RSQLTagFieldsTest extends AbstractIntegrationTest {
public class RSQLTagFieldsTest extends AbstractJpaIntegrationTest {
@Before
public void seuptBeforeTest() {

22
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/rsql/RSQLTargetFieldTest.java
View File

@@ -15,8 +15,7 @@ import java.util.Arrays;
import org.eclipse.hawkbit.repository.TargetFields;
import org.eclipse.hawkbit.repository.exception.RSQLParameterUnsupportedFieldException;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.TestDataUtil;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetInfo;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetTag;
@@ -25,6 +24,7 @@ import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.model.TargetInfo;
import org.eclipse.hawkbit.repository.model.TargetTag;
import org.eclipse.hawkbit.repository.model.TargetUpdateStatus;
import org.eclipse.hawkbit.repository.util.TestdataFactory;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.domain.Page;
@@ -36,19 +36,17 @@ import ru.yandex.qatools.allure.annotations.Stories;
@Features("Component Tests - Repository")
@Stories("RSQL filter target")
public class RSQLTargetFieldTest extends AbstractIntegrationTest {
public class RSQLTargetFieldTest extends AbstractJpaIntegrationTest {
@Before
public void seuptBeforeTest() {
final DistributionSet ds = TestDataUtil.generateDistributionSet("AssignedDs", softwareManagement,
distributionSetManagement);
final DistributionSet ds = testdataFactory.createDistributionSet("AssignedDs");
final JpaTarget target = new JpaTarget("targetId123");
final Target target = entityFactory.generateTarget("targetId123");
target.setDescription("targetId123");
final TargetInfo targetInfo = new JpaTargetInfo(target);
final TargetInfo targetInfo = target.getTargetInfo();
targetInfo.getControllerAttributes().put("revision", "1.1");
target.setTargetInfo(targetInfo);
((JpaTargetInfo) target.getTargetInfo()).setUpdateStatus(TargetUpdateStatus.PENDING);
targetManagement.createTarget(target);
@@ -149,11 +147,13 @@ public class RSQLTargetFieldTest extends AbstractIntegrationTest {
@Test
@Description("Test filter target by assigned ds version")
public void testFilterByAssignedDsVersion() {
assertRSQLQuery(TargetFields.ASSIGNEDDS.name() + ".version==v1.0", 1);
assertRSQLQuery(TargetFields.ASSIGNEDDS.name() + ".version==" + TestdataFactory.DEFAULT_VERSION, 1);
assertRSQLQuery(TargetFields.ASSIGNEDDS.name() + ".version==*1*", 1);
assertRSQLQuery(TargetFields.ASSIGNEDDS.name() + ".version==noExist*", 0);
assertRSQLQuery(TargetFields.ASSIGNEDDS.name() + ".version=in=(v1.0,notexist)", 1);
assertRSQLQuery(TargetFields.ASSIGNEDDS.name() + ".version=out=(v1.0,notexist)", 0);
assertRSQLQuery(
TargetFields.ASSIGNEDDS.name() + ".version=in=(" + TestdataFactory.DEFAULT_VERSION + ",notexist)", 1);
assertRSQLQuery(
TargetFields.ASSIGNEDDS.name() + ".version=out=(" + TestdataFactory.DEFAULT_VERSION + ",notexist)", 0);
}
@Test

8
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/tenancy/MultiTenancyEntityTest.java
View File

@@ -10,14 +10,14 @@ package org.eclipse.hawkbit.repository.jpa.tenancy;
import static org.fest.assertions.api.Assertions.assertThat;
import org.eclipse.hawkbit.repository.jpa.AbstractIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.WithSpringAuthorityRule;
import org.eclipse.hawkbit.repository.jpa.WithUser;
import org.eclipse.hawkbit.repository.jpa.AbstractJpaIntegrationTest;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSet;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetType;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.Target;
import org.eclipse.hawkbit.repository.util.WithSpringAuthorityRule;
import org.eclipse.hawkbit.repository.util.WithUser;
import org.junit.Test;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Slice;
@@ -34,7 +34,7 @@ import ru.yandex.qatools.allure.annotations.Stories;
*/
@Features("Component Tests - Repository")
@Stories("Multi Tenancy")
public class MultiTenancyEntityTest extends AbstractIntegrationTest {
public class MultiTenancyEntityTest extends AbstractJpaIntegrationTest {
@Test
@Description(value = "Ensures that multiple targets with same controller-ID can be created for different tenants.")

485
hawkbit-repository/hawkbit-repository-jpa/src/test/java/org/eclipse/hawkbit/repository/jpa/utils/RepositoryDataGenerator.java
View File

@@ -1,485 +0,0 @@
/**
* Copyright (c) 2015 Bosch Software Innovations GmbH and others.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*/
package org.eclipse.hawkbit.repository.jpa.utils;
import java.net.URI;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.IntStream;
import javax.persistence.EntityManager;
import javax.persistence.Query;
import javax.transaction.Transactional;
import org.eclipse.hawkbit.im.authentication.SpPermission;
import org.eclipse.hawkbit.im.authentication.SpPermission.SpringEvalExpressions;
import org.eclipse.hawkbit.im.authentication.TenantAwareAuthenticationDetails;
import org.eclipse.hawkbit.repository.ControllerManagement;
import org.eclipse.hawkbit.repository.DeploymentManagement;
import org.eclipse.hawkbit.repository.DistributionSetAssignmentResult;
import org.eclipse.hawkbit.repository.DistributionSetManagement;
import org.eclipse.hawkbit.repository.SoftwareManagement;
import org.eclipse.hawkbit.repository.TagManagement;
import org.eclipse.hawkbit.repository.TargetManagement;
import org.eclipse.hawkbit.repository.jpa.TestDataUtil;
import org.eclipse.hawkbit.repository.jpa.model.JpaActionStatus;
import org.eclipse.hawkbit.repository.jpa.model.JpaDistributionSetTag;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModule;
import org.eclipse.hawkbit.repository.jpa.model.JpaSoftwareModuleType;
import org.eclipse.hawkbit.repository.jpa.model.JpaTarget;
import org.eclipse.hawkbit.repository.jpa.model.JpaTargetTag;
import org.eclipse.hawkbit.repository.model.Action;
import org.eclipse.hawkbit.repository.model.Action.Status;
import org.eclipse.hawkbit.repository.model.ActionStatus;
import org.eclipse.hawkbit.repository.model.DistributionSet;
import org.eclipse.hawkbit.repository.model.DistributionSetTag;
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.TargetUpdateStatus;
import org.eclipse.hawkbit.util.IpUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.data.auditing.AuditingHandler;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.security.authentication.TestingAuthenticationToken;
import org.springframework.security.core.context.SecurityContext;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.context.SecurityContextImpl;
import net._01001111.text.LoremIpsum;
/**
* Generates test data for setting up the repository for test or demonstration
* purpose.
*
*
*
*/
public final class RepositoryDataGenerator {
private static final Logger LOG = LoggerFactory.getLogger(RepositoryDataGenerator.class);
public static void initDemoRepo(final ConfigurableApplicationContext context) {
final PersistentInitDemoDataBuilder initDemoDataBuilder = new PersistentInitDemoDataBuilder(context);
initDemoDataBuilder.initDemoRepo(20, 0);
}
public static void initLoadRepo(final ConfigurableApplicationContext context) {
final PersistentInitDemoDataBuilder initDemoDataBuilder = new PersistentInitDemoDataBuilder(context);
initDemoDataBuilder.initDemoRepo(200, 200);
}
/**
* builder which build initial demo data and stores it to the repos.
*
*/
private static final class PersistentInitDemoDataBuilder {
private final SoftwareManagement softwareManagement;
private final TargetManagement targetManagement;
private final DeploymentManagement deploymentManagement;
private final TagManagement tagManagement;
private final ControllerManagement controllerManagement;
private final DistributionSetManagement distributionSetManagement;
private final DatabaseCleanupUtil dbCleanupUtil;
private final AuditingHandler auditingHandler;
final LoremIpsum jlorem = new LoremIpsum();
PersistentInitDemoDataBuilder(final ConfigurableApplicationContext context) {
softwareManagement = context.getBean(SoftwareManagement.class);
targetManagement = context.getBean(TargetManagement.class);
tagManagement = context.getBean(TagManagement.class);
deploymentManagement = context.getBean(DeploymentManagement.class);
controllerManagement = context.getBean(ControllerManagement.class);
distributionSetManagement = context.getBean(DistributionSetManagement.class);
dbCleanupUtil = context.getBean(DatabaseCleanupUtil.class);
auditingHandler = context.getBean(AuditingHandler.class);
}
private void runAsAllAuthorityContext(final Runnable runnable) {
final SecurityContext oldContext = SecurityContextHolder.getContext();
try {
final SecurityContextImpl securityContextImpl = new SecurityContextImpl();
final TestingAuthenticationToken authentication = new TestingAuthenticationToken("repogenator",
"repogenator", SpPermission.CREATE_REPOSITORY, SpPermission.CREATE_TARGET,
SpPermission.DELETE_REPOSITORY, SpPermission.DELETE_TARGET, SpPermission.READ_REPOSITORY,
SpPermission.READ_TARGET, SpPermission.UPDATE_REPOSITORY, SpPermission.UPDATE_TARGET,
SpringEvalExpressions.CONTROLLER_ROLE);
securityContextImpl.setAuthentication(authentication);
authentication.setDetails(new TenantAwareAuthenticationDetails("default", false));
SecurityContextHolder.setContext(securityContextImpl);
runnable.run();
} finally {
SecurityContextHolder.setContext(oldContext);
}
}
public void generateTestTagetGroup(final String group, final int sizeMultiplikator) {
final DistributionSetTag dsTag = tagManagement
.createDistributionSetTag(new JpaDistributionSetTag("For " + group + "s"));
auditingHandler.setDateTimeProvider(() -> {
final Calendar instance = Calendar.getInstance();
instance.add(Calendar.MONTH, -new Random().nextInt(7));
return instance;
});
final List<Target> targets = createTargetTestGroup(group, 20 * sizeMultiplikator);
auditingHandler.setDateTimeProvider(() -> {
final Calendar instance = Calendar.getInstance();
return instance;
});
LOG.debug("initDemoRepo - start now real action history for group: {}", group);
// Old history of succesfully finished operations
IntStream.range(0, 10).forEach(idx -> {
final DistributionSet dsReal = TestDataUtil.generateDistributionSet(group + " Release", "v1." + idx,
softwareManagement, distributionSetManagement,
Arrays.asList(new DistributionSetTag[] { dsTag }));
final DistributionSetAssignmentResult result = deploymentManagement.assignDistributionSet(dsReal,
targets);
createSimpleActionStatusHistory(result.getActions());
});
final List<List<Target>> targetGroups = splitIntoGroups(targets);
IntStream.range(0, targetGroups.size()).forEach(idx -> {
final DistributionSet dsReal = TestDataUtil.generateDistributionSet(group + " Release", "v2." + idx,
softwareManagement, distributionSetManagement,
Arrays.asList(new DistributionSetTag[] { dsTag }));
final DistributionSetAssignmentResult result = deploymentManagement.assignDistributionSet(dsReal,
targetGroups.get(idx));
createActionStatusHistory(result.getActions(), sizeMultiplikator);
});
LOG.debug("initDemoRepo - real action history finished for group: {}", group);
}
private List<List<Target>> splitIntoGroups(final List<Target> allTargets) {
final int elements = allTargets.size();
final int group1 = elements * (5 + new Random().nextInt(5)) / 100;
final int group2 = elements * (15 + new Random().nextInt(5)) / 100;
final List<List<Target>> result = new ArrayList<List<Target>>();
result.add(allTargets.subList(0, group1));
result.add(allTargets.subList(group1, group2));
result.add(allTargets.subList(group2, elements));
return result;
}
private void createActionStatusHistory(final List<Long> actions, final int sizeMultiplikator) {
final AtomicInteger counter = new AtomicInteger();
int index = 0;
for (final Long actionGiven : actions) {
// retrieved
Action action = controllerManagement.registerRetrieved(
deploymentManagement.findActionWithDetails(actionGiven),
"Controller retrieved update action and should start now the download.");
// download
final ActionStatus download = new JpaActionStatus();
download.setAction(action);
download.setStatus(Status.DOWNLOAD);
download.addMessage("Controller started download.");
action = controllerManagement.addUpdateActionStatus(download);
// warning
final ActionStatus warning = new JpaActionStatus();
warning.setAction(action);
warning.setStatus(Status.WARNING);
warning.addMessage("Some warning: " + jlorem.words(new Random().nextInt(50)));
action = controllerManagement.addUpdateActionStatus(warning);
// garbage
for (int i = 0; i < new Random().nextInt(10); i++) {
final ActionStatus running = new JpaActionStatus();
running.setAction(action);
running.setStatus(Status.RUNNING);
running.addMessage("Still running: " + jlorem.words(new Random().nextInt(50)));
action = controllerManagement.addUpdateActionStatus(running);
for (int g = 0; g < new Random().nextInt(5); g++) {
final ActionStatus rand = new JpaActionStatus();
rand.setAction(action);
rand.setStatus(Status.RUNNING);
rand.addMessage(jlorem.words(new Random().nextInt(50)));
action = controllerManagement.addUpdateActionStatus(rand);
}
}
// close
final ActionStatus close = new JpaActionStatus();
close.setAction(action);
// with error
final int incrementAndGet = counter.incrementAndGet();
if (incrementAndGet % 5 == 0) {
close.setStatus(Status.ERROR);
close.addMessage("Controller reported CLOSED with ERROR!");
action = controllerManagement.addUpdateActionStatus(close);
}
// with OK
else {
close.setStatus(Status.FINISHED);
close.addMessage("Controller reported CLOSED with OK!");
action = controllerManagement.addUpdateActionStatus(close);
}
index++;
}
}
private void createSimpleActionStatusHistory(final List<Long> actions) {
for (final Long actionGiven : actions) {
// retrieved
Action action = controllerManagement.registerRetrieved(
deploymentManagement.findActionWithDetails(actionGiven),
"Controller retrieved update action and should start now the download.");
// close
final ActionStatus close = new JpaActionStatus();
close.setAction(action);
close.setStatus(Status.FINISHED);
close.addMessage("Controller reported CLOSED with OK!");
action = controllerManagement.addUpdateActionStatus(close);
}
}
private List<Target> createTargetTestGroup(final String group, final int targets) {
LOG.debug("createTargetTestGroup: create group {}", group);
final TargetTag targTag = tagManagement.createTargetTag(new JpaTargetTag(group));
final List<Target> targAs = targetManagement.createTargets(buildTargets(targets, group),
TargetUpdateStatus.REGISTERED, System.currentTimeMillis() - new Random().nextInt(50_000_000),
generateIPAddress());
LOG.debug("createTargetTestGroup: {} created", group);
LOG.debug("createTargetTestGroup: {} targets status updated including IP", group);
return targetManagement.toggleTagAssignment(targAs, targTag).getAssignedEntity();
}
private List<Target> buildTargets(final int noOfTgts, final String descriptionPrefix) {
final List<Target> result = new ArrayList<Target>(noOfTgts);
for (int i = 0; i < noOfTgts; i++) {
final Target target = new JpaTarget(UUID.randomUUID().toString());
final StringBuilder builder = new StringBuilder();
builder.append(descriptionPrefix);
builder.append(jlorem.words(5));
target.setDescription(builder.toString());
target.getTargetInfo().getControllerAttributes().put("revision", "1.1");
target.getTargetInfo().getControllerAttributes().put("capacity", "128M");
target.getTargetInfo().getControllerAttributes().put("serial",
String.valueOf(System.currentTimeMillis()));
result.add(target);
}
return result;
}
/**
* method writes initial test/demo data to the repositories.
*
* @param sizeMultiplikator
* the entire scenario
* @param loadtestgroups
* packages of 1_000 targets
*/
private void initDemoRepo(final int sizeMultiplikator, final int loadtestgroups) {
final LoremIpsum jlorem = new LoremIpsum();
runAsAllAuthorityContext(() -> {
dbCleanupUtil.cleanupDB(null);
// generate targets and assign DS
// 5 groups - 100 targets each -> 500
final String[] targetTestGroups = { "SHC", "CCU", "Vehicle", "Vending machine", "ECU" };
final String[] modulesTypes = { "HeadUnit_FW", "EDC17_FW", "OSGi_Bundle" };
final DistributionSetTag depTag = tagManagement
.createDistributionSetTag(new JpaDistributionSetTag("deprecated"));
Arrays.stream(targetTestGroups).forEach(group -> {
generateTestTagetGroup(group, sizeMultiplikator);
});
// garbage DS
LOG.debug("initDemoRepo - start now DS garbage");
TestDataUtil.generateDistributionSets("Generic Software Package", sizeMultiplikator, softwareManagement,
distributionSetManagement);
LOG.debug("initDemoRepo - DS garbage finished");
LOG.debug("initDemoRepo - start now Extra Software Modules and types");
Arrays.stream(modulesTypes).forEach(typeName -> {
final SoftwareModuleType smtype = softwareManagement.createSoftwareModuleType(
new JpaSoftwareModuleType(typeName.toLowerCase().replaceAll("\\s+", ""), typeName,
jlorem.words(5), Integer.MAX_VALUE));
for (int i1 = 0; i1 < sizeMultiplikator; i1++) {
softwareManagement.createSoftwareModule(new JpaSoftwareModule(smtype, typeName + i1, "1.0." + i1,
jlorem.words(5), "the " + typeName + " vendor Inc."));
}
});
LOG.debug("initDemoRepo - Extra Software Modules and types finished");
LOG.debug("initDemoRepo - start now target garbage");
// garbage targets
// unknown
targetManagement
.createTargets(TestDataUtil.generateTargets(targetTestGroups.length * sizeMultiplikator));
// registered
targetManagement.createTargets(
TestDataUtil.generateTargets(targetTestGroups.length * sizeMultiplikator, "registered"),
TargetUpdateStatus.REGISTERED, System.currentTimeMillis(), generateIPAddress());
// pending
final DistributionSetTag dsTag = tagManagement
.createDistributionSetTag(new JpaDistributionSetTag("OnlyAssignedTag"));
final DistributionSet ds = TestDataUtil.generateDistributionSet("Pending DS", "v1.0",
softwareManagement, distributionSetManagement,
Arrays.asList(new DistributionSetTag[] { dsTag }));
deploymentManagement.assignDistributionSet(ds, targetManagement.createTargets(
TestDataUtil.generateTargets(targetTestGroups.length * sizeMultiplikator, "pending")));
// Load test means additional 1_000_000 target
for (int i2 = 0; i2 < loadtestgroups; i2++) {
targetManagement.createTargets(TestDataUtil.generateTargets(i2 * 1_000, 1_000, "loadtest-"));
}
LOG.debug("initDemoRepo complete");
});
}
/**
* Adding controller attributes for given {@link Target}.
*/
// private Target setControllerAttributes( final String targetId ) {
// final Target target =
// targetManagement.findTargetByControllerIDWithDetails( targetId );
// target.getTargetStatus().getControllerAttributes().put( "revision",
// "1.1" );
// target.getTargetStatus().getControllerAttributes().put( "capacity",
// "128M" );
// target.getTargetStatus().getControllerAttributes().put( "serial",
// String.valueOf(
// System.currentTimeMillis()) );
// return targetManagement.updateTarget( target );
// }
}
/**
*
* Data clean up class.
*
*
*
*/
public static class DatabaseCleanupUtil {
private static final Logger LOG = LoggerFactory.getLogger(DatabaseCleanupUtil.class);
@Autowired
private EntityManager entityManager;
private static final String[] CLEAN_UP_SQLS = new String[] { "sp_tenant", "sp_tenant_configuration",
"sp_artifact", "sp_external_artifact", "sp_external_provider", "sp_target_target_tag",
"sp_target_attributes", "sp_target_tag", "sp_action_status_messages", "sp_action_status", "sp_action",
"sp_ds_dstag", "sp_distributionset_tag", "sp_target_info", "sp_target", "sp_sw_metadata",
"sp_ds_metadata", "sp_ds_module", "sp_distribution_set", "sp_base_software_module",
"sp_ds_type_element", "sp_distribution_set_type", "sp_software_module_type" };
/**
* delete all entries from the DB tables.
*/
@Transactional
@Modifying
public void cleanupDB(final String database) {
LOG.debug("Data clean up is started...");
final boolean isMySql = "MYSQL".equals(database);
if (isMySql) {
// disable foreign key check because otherwise mysql cannot
// delete sp_active_actions due
// the self constraint within the table, stupid MySql
entityManager.createNativeQuery("SET FOREIGN_KEY_CHECKS = 0").executeUpdate();
}
try {
final String[] dbCmds = new String[] { "delete from" };
for (final String dbCmd : dbCmds) {
for (final String table : CLEAN_UP_SQLS) {
final String sql = String.format("%s %s", dbCmd, table);
final Query query = entityManager.createNativeQuery(sql);
try {
LOG.debug("cleanup table: {}", sql);
LOG.debug("cleaned table: {}; deleted {} records", sql, query.executeUpdate());
} catch (final Exception ex) {
LOG.error(String.format("error on executing cleanup statement '%s'", sql), ex);
throw ex;
}
}
}
LOG.debug("Data clean up is finished...");
} finally {
if (isMySql) {
// enable foreign key check again!
entityManager.createNativeQuery("SET FOREIGN_KEY_CHECKS = 1").executeUpdate();
}
}
}
}
/**
* @return a generated IPv4 address string.
*/
private static URI generateIPAddress() {
final Random r = new Random();
return IpUtil
.createHttpUri(r.nextInt(256) + "." + r.nextInt(256) + "." + r.nextInt(256) + "." + r.nextInt(256));
}
private RepositoryDataGenerator() {
super();
}
}