Apache
/
nifi
mirror of https://github.com/apache/nifi.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

NIFI-11116 Refactored nifi-registry-core to use JUnit 5 

This closes #6929

Signed-off-by: David Handermann <exceptionfactory@apache.org>
This commit is contained in:
mkalavala 2023-02-06 14:35:00 -05:00 committed by exceptionfactory
parent 99b0cd42ef
commit 889767683c
No known key found for this signature in database
GPG Key ID: 29B6A52D2AAE8DBA
46 changed files with 504 additions and 492 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/db/DatabaseBaseTest.java
View File

@ -16,16 +16,16 @@
*/
package org.apache.nifi.registry.db;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;
import org.springframework.test.context.transaction.TransactionalTestExecutionListener;
import org.springframework.transaction.annotation.Transactional;
@Transactional
@RunWith(SpringRunner.class)
@ExtendWith(SpringExtension.class)
@SpringBootTest(classes = DatabaseTestApplication.class, webEnvironment = SpringBootTest.WebEnvironment.NONE)
@TestExecutionListeners({DependencyInjectionTestExecutionListener.class, TransactionalTestExecutionListener.class})
public abstract class DatabaseBaseTest {

8
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/db/TestDatabaseKeyService.java
View File

@ -18,12 +18,12 @@ package org.apache.nifi.registry.db;
import org.apache.nifi.registry.security.key.Key;
import org.apache.nifi.registry.security.key.KeyService;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
public class TestDatabaseKeyService extends DatabaseBaseTest {

12
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/db/TestDatabaseMetadataService.java
View File

@ -36,7 +36,7 @@ import org.apache.nifi.extension.ExtensionFilterParams;
import org.apache.nifi.extension.manifest.ExtensionType;
import org.apache.nifi.extension.manifest.ProvidedServiceAPI;
import org.apache.nifi.registry.service.MetadataService;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.Arrays;
@ -47,11 +47,11 @@ import java.util.List;
import java.util.Set;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class TestDatabaseMetadataService extends DatabaseBaseTest {

6
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/db/migration/TestLegacyEntityMapper.java
View File

@ -19,12 +19,12 @@ package org.apache.nifi.registry.db.migration;
import org.apache.nifi.registry.db.entity.BucketEntity;
import org.apache.nifi.registry.db.entity.FlowEntity;
import org.apache.nifi.registry.db.entity.FlowSnapshotEntity;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.Date;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
public class TestLegacyEntityMapper {

8
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/event/TestEventFactory.java
View File

@ -30,12 +30,12 @@ import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.registry.hook.Event;
import org.apache.nifi.registry.hook.EventFieldName;
import org.apache.nifi.registry.hook.EventType;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestEventFactory {
@ -47,7 +47,7 @@ public class TestEventFactory {
private User user;
private UserGroup userGroup;
@Before
@BeforeEach
public void setup() {
bucket = new Bucket();
bucket.setName("Bucket1");

19
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/event/TestEventService.java
View File

@ -22,29 +22,30 @@ import org.apache.nifi.registry.hook.EventHookException;
import org.apache.nifi.registry.hook.EventHookProvider;
import org.apache.nifi.registry.provider.ProviderConfigurationContext;
import org.apache.nifi.registry.provider.ProviderCreationException;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestEventService {
private CapturingEventHook eventHook;
private EventService eventService;
@Before
@BeforeEach
public void setup() {
eventHook = new CapturingEventHook();
eventService = new EventService(Collections.singletonList(eventHook));
eventService.postConstruct();
}
@After
@AfterEach
public void teardown() throws Exception {
eventService.destroy();
}
@ -63,13 +64,13 @@ public class TestEventService {
Thread.sleep(1000);
final List<Event> events = eventHook.getEvents();
Assert.assertEquals(2, events.size());
assertEquals(2, events.size());
final Event firstEvent = events.get(0);
Assert.assertEquals(bucketCreatedEvent.getEventType(), firstEvent.getEventType());
assertEquals(bucketCreatedEvent.getEventType(), firstEvent.getEventType());
final Event secondEvent = events.get(1);
Assert.assertEquals(bucketDeletedEvent.getEventType(), secondEvent.getEventType());
assertEquals(bucketDeletedEvent.getEventType(), secondEvent.getEventType());
}
/**

12
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/event/TestStandardEvent.java
View File

@ -20,18 +20,20 @@ import org.apache.nifi.registry.hook.Event;
import org.apache.nifi.registry.hook.EventField;
import org.apache.nifi.registry.hook.EventFieldName;
import org.apache.nifi.registry.hook.EventType;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class TestStandardEvent {
@Test(expected = IllegalStateException.class)
@Test
public void testInvalidEvent() {
final Event event = new StandardEvent.Builder()
.eventType(EventType.CREATE_BUCKET)
.build();
event.validate();
assertThrows(IllegalStateException.class, () -> event.validate());
}
@Test
@ -41,7 +43,7 @@ public class TestStandardEvent {
.build();
final EventField field = event.getField(EventFieldName.BUCKET_ID);
Assert.assertNull(field);
assertNull(field);
}
}

19
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/TestStandardProviderFactory.java
View File

@ -21,15 +21,16 @@ import org.apache.nifi.registry.extension.ExtensionClassLoader;
import org.apache.nifi.registry.extension.ExtensionManager;
import org.apache.nifi.registry.flow.FlowPersistenceProvider;
import org.apache.nifi.registry.properties.NiFiRegistryProperties;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import javax.sql.DataSource;
import java.net.URL;
import java.util.Properties;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.when;
@ -67,7 +68,7 @@ public class TestStandardProviderFactory {
assertEquals("extension bar", mockBundlePersistenceProvider.getProperties().get("Extension Property 2"));
}
@Test(expected = ProviderFactoryException.class)
@Test
public void testGetFlowProviderBeforeInitializingShouldThrowException() {
final Properties properties = new Properties();
properties.setProperty(NiFiRegistryProperties.PROVIDERS_CONFIGURATION_FILE, "src/test/resources/provider/providers-good.xml");
@ -80,10 +81,10 @@ public class TestStandardProviderFactory {
final DataSource dataSource = Mockito.mock(DataSource.class);
final ProviderFactory providerFactory = new StandardProviderFactory(props, extensionManager, dataSource);
providerFactory.getFlowPersistenceProvider();
assertThrows(ProviderFactoryException.class, () -> providerFactory.getFlowPersistenceProvider());
}
@Test(expected = ProviderFactoryException.class)
@Test
public void testProvidersConfigDoesNotExist() {
final Properties properties = new Properties();
properties.setProperty(NiFiRegistryProperties.PROVIDERS_CONFIGURATION_FILE, "src/test/resources/provider/providers-does-not-exist.xml");
@ -96,10 +97,10 @@ public class TestStandardProviderFactory {
final DataSource dataSource = Mockito.mock(DataSource.class);
final ProviderFactory providerFactory = new StandardProviderFactory(props, extensionManager, dataSource);
providerFactory.initialize();
assertThrows(ProviderFactoryException.class, () -> providerFactory.initialize());
}
@Test(expected = ProviderFactoryException.class)
@Test
public void testFlowProviderClassNotFound() {
final Properties properties = new Properties();
properties.setProperty(NiFiRegistryProperties.PROVIDERS_CONFIGURATION_FILE, "src/test/resources/provider/providers-class-not-found.xml");
@ -114,7 +115,7 @@ public class TestStandardProviderFactory {
final ProviderFactory providerFactory = new StandardProviderFactory(props, extensionManager, dataSource);
providerFactory.initialize();
providerFactory.getFlowPersistenceProvider();
assertThrows(ProviderFactoryException.class, () -> providerFactory.getFlowPersistenceProvider());
}
}

45
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/extension/TestFileSystemBundlePersistenceProvider.java
View File

@ -24,9 +24,8 @@ import org.apache.nifi.registry.extension.BundlePersistenceProvider;
import org.apache.nifi.registry.extension.BundleVersionCoordinate;
import org.apache.nifi.registry.extension.BundleVersionType;
import org.apache.nifi.registry.provider.ProviderConfigurationContext;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.io.ByteArrayInputStream;
@ -40,6 +39,11 @@ import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.when;
public class TestFileSystemBundlePersistenceProvider {
@ -58,7 +62,7 @@ public class TestFileSystemBundlePersistenceProvider {
private File bundleStorageDir;
private BundlePersistenceProvider fileSystemBundleProvider;
@Before
@BeforeEach
public void setup() throws IOException {
bundleStorageDir = new File(EXTENSION_STORAGE_DIR);
if (bundleStorageDir.exists()) {
@ -66,11 +70,11 @@ public class TestFileSystemBundlePersistenceProvider {
bundleStorageDir.delete();
}
Assert.assertFalse(bundleStorageDir.exists());
assertFalse(bundleStorageDir.exists());
fileSystemBundleProvider = new FileSystemBundlePersistenceProvider();
fileSystemBundleProvider.onConfigured(CONFIGURATION_CONTEXT);
Assert.assertTrue(bundleStorageDir.exists());
assertTrue(bundleStorageDir.exists());
}
@Test
@ -109,7 +113,7 @@ public class TestFileSystemBundlePersistenceProvider {
try {
final String newContent = "new content";
createBundleVersion(fileSystemBundleProvider, versionCoordinate, newContent);
Assert.fail("Should have thrown exception");
fail("Should have thrown exception");
} catch (BundlePersistenceException e) {
// expected
}
@ -136,7 +140,7 @@ public class TestFileSystemBundlePersistenceProvider {
try (final OutputStream out = new ByteArrayOutputStream()) {
fileSystemBundleProvider.getBundleVersionContent(versionCoordinate, out);
final String retrievedContent = new String(((ByteArrayOutputStream) out).toByteArray(), StandardCharsets.UTF_8);
Assert.assertEquals(newContent, retrievedContent);
assertEquals(newContent, retrievedContent);
}
}
@ -159,18 +163,18 @@ public class TestFileSystemBundlePersistenceProvider {
fileSystemBundleProvider.getBundleVersionContent(versionCoordinate1, out);
final String retrievedContent1 = new String(((ByteArrayOutputStream) out).toByteArray(), StandardCharsets.UTF_8);
Assert.assertEquals(content1, retrievedContent1);
assertEquals(content1, retrievedContent1);
}
try (final OutputStream out = new ByteArrayOutputStream()) {
fileSystemBundleProvider.getBundleVersionContent(versionCoordinate2, out);
final String retrievedContent2 = new String(((ByteArrayOutputStream) out).toByteArray(), StandardCharsets.UTF_8);
Assert.assertEquals(content2, retrievedContent2);
assertEquals(content2, retrievedContent2);
}
}
@Test(expected = BundlePersistenceException.class)
@Test
public void testGetWhenDoesNotExist() throws IOException {
final String bucketId = "b1";
final String groupId = "g1";
@ -180,8 +184,7 @@ public class TestFileSystemBundlePersistenceProvider {
try (final OutputStream out = new ByteArrayOutputStream()) {
final BundleVersionCoordinate versionCoordinate = getVersionCoordinate(bucketId, groupId, artifactId, version, type);
fileSystemBundleProvider.getBundleVersionContent(versionCoordinate, out);
Assert.fail("Should have thrown exception");
assertThrows(BundlePersistenceException.class, () -> fileSystemBundleProvider.getBundleVersionContent(versionCoordinate, out));
}
}
@ -206,7 +209,7 @@ public class TestFileSystemBundlePersistenceProvider {
// verify it was deleted
final File bundleVersionDir = FileSystemBundlePersistenceProvider.getBundleVersionDirectory(bundleStorageDir, versionCoordinate);
final File bundleFile = FileSystemBundlePersistenceProvider.getBundleFile(bundleVersionDir, versionCoordinate);
Assert.assertFalse(bundleFile.exists());
assertFalse(bundleFile.exists());
}
@Test
@ -222,7 +225,7 @@ public class TestFileSystemBundlePersistenceProvider {
// verify the bundle version does not already exist
final File bundleVersionDir = FileSystemBundlePersistenceProvider.getBundleVersionDirectory(bundleStorageDir, versionCoordinate);
final File bundleFile = FileSystemBundlePersistenceProvider.getBundleFile(bundleVersionDir, versionCoordinate);
Assert.assertFalse(bundleFile.exists());
assertFalse(bundleFile.exists());
// delete the bundle version
fileSystemBundleProvider.deleteBundleVersion(versionCoordinate);
@ -249,10 +252,10 @@ public class TestFileSystemBundlePersistenceProvider {
createBundleVersion(fileSystemBundleProvider, versionCoordinate2, content2);
verifyBundleVersion(bundleStorageDir, versionCoordinate2, content2);
Assert.assertEquals(1, bundleStorageDir.listFiles().length);
assertEquals(1, bundleStorageDir.listFiles().length);
final BundleCoordinate bundleCoordinate = getBundleCoordinate(bucketId, groupId, artifactId);
fileSystemBundleProvider.deleteAllBundleVersions(bundleCoordinate);
Assert.assertEquals(0, bundleStorageDir.listFiles().length);
assertEquals(0, bundleStorageDir.listFiles().length);
}
@Test
@ -261,10 +264,10 @@ public class TestFileSystemBundlePersistenceProvider {
final String groupId = "g1";
final String artifactId = "a1";
Assert.assertEquals(0, bundleStorageDir.listFiles().length);
assertEquals(0, bundleStorageDir.listFiles().length);
final BundleCoordinate bundleCoordinate = getBundleCoordinate(bucketId, groupId, artifactId);
fileSystemBundleProvider.deleteAllBundleVersions(bundleCoordinate);
Assert.assertEquals(0, bundleStorageDir.listFiles().length);
assertEquals(0, bundleStorageDir.listFiles().length);
}
private void createBundleVersion(final BundlePersistenceProvider persistenceProvider,
@ -316,10 +319,10 @@ public class TestFileSystemBundlePersistenceProvider {
final File bundleVersionDir = FileSystemBundlePersistenceProvider.getBundleVersionDirectory(storageDir, versionCoordinate);
final File bundleFile = FileSystemBundlePersistenceProvider.getBundleFile(bundleVersionDir, versionCoordinate);
Assert.assertTrue(bundleFile.exists());
assertTrue(bundleFile.exists());
try (InputStream in = new FileInputStream(bundleFile)) {
Assert.assertEquals(contentString, IOUtils.toString(in, StandardCharsets.UTF_8));
assertEquals(contentString, IOUtils.toString(in, StandardCharsets.UTF_8));
}
}

12
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/flow/TestDatabaseFlowPersistenceProvider.java
View File

@ -19,17 +19,17 @@ package org.apache.nifi.registry.provider.flow;
import org.apache.nifi.registry.db.DatabaseBaseTest;
import org.apache.nifi.registry.flow.FlowPersistenceProvider;
import org.apache.nifi.registry.flow.FlowSnapshotContext;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import javax.sql.DataSource;
import java.nio.charset.StandardCharsets;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.mockito.Mockito.when;
public class TestDatabaseFlowPersistenceProvider extends DatabaseBaseTest {
@ -39,7 +39,7 @@ public class TestDatabaseFlowPersistenceProvider extends DatabaseBaseTest {
private FlowPersistenceProvider persistenceProvider;
@Before
@BeforeEach
public void setup() {
persistenceProvider = new DatabaseFlowPersistenceProvider();
((DatabaseFlowPersistenceProvider)persistenceProvider).setDataSource(dataSource);

51
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/flow/TestFileSystemFlowPersistenceProvider.java
View File

@ -20,9 +20,8 @@ import org.apache.commons.io.IOUtils;
import org.apache.nifi.registry.flow.FlowPersistenceProvider;
import org.apache.nifi.registry.flow.FlowSnapshotContext;
import org.apache.nifi.registry.provider.ProviderConfigurationContext;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import java.io.File;
@ -33,6 +32,12 @@ import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.when;
public class TestFileSystemFlowPersistenceProvider {
@ -51,7 +56,7 @@ public class TestFileSystemFlowPersistenceProvider {
private File flowStorageDir;
private FileSystemFlowPersistenceProvider fileSystemFlowProvider;
@Before
@BeforeEach
public void setup() throws IOException {
flowStorageDir = new File(FLOW_STORAGE_DIR);
if (flowStorageDir.exists()) {
@ -59,11 +64,11 @@ public class TestFileSystemFlowPersistenceProvider {
flowStorageDir.delete();
}
Assert.assertFalse(flowStorageDir.exists());
assertFalse(flowStorageDir.exists());
fileSystemFlowProvider = new FileSystemFlowPersistenceProvider();
fileSystemFlowProvider.onConfigured(CONFIGURATION_CONTEXT);
Assert.assertTrue(flowStorageDir.exists());
assertTrue(flowStorageDir.exists());
}
@Test
@ -95,7 +100,7 @@ public class TestFileSystemFlowPersistenceProvider {
final byte[] content2 = "XXX".getBytes(StandardCharsets.UTF_8);
try {
fileSystemFlowProvider.saveFlowContent(context, content2);
Assert.fail("Should have thrown exception");
fail("Should have thrown exception");
} catch (Exception e) {
}
@ -103,7 +108,7 @@ public class TestFileSystemFlowPersistenceProvider {
// verify the new content wasn't written
final File flowSnapshotFile = new File(flowStorageDir, "bucket1/flow1/1/1" + FileSystemFlowPersistenceProvider.SNAPSHOT_EXTENSION);
try (InputStream in = new FileInputStream(flowSnapshotFile)) {
Assert.assertEquals("flow1v1", IOUtils.toString(in, StandardCharsets.UTF_8));
assertEquals("flow1v1", IOUtils.toString(in, StandardCharsets.UTF_8));
}
}
@ -113,16 +118,16 @@ public class TestFileSystemFlowPersistenceProvider {
createAndSaveSnapshot(fileSystemFlowProvider,"bucket1", "flow1", 2, "flow1v2");
final byte[] flow1v1 = fileSystemFlowProvider.getFlowContent("bucket1", "flow1", 1);
Assert.assertEquals("flow1v1", new String(flow1v1, StandardCharsets.UTF_8));
assertEquals("flow1v1", new String(flow1v1, StandardCharsets.UTF_8));
final byte[] flow1v2 = fileSystemFlowProvider.getFlowContent("bucket1", "flow1", 2);
Assert.assertEquals("flow1v2", new String(flow1v2, StandardCharsets.UTF_8));
assertEquals("flow1v2", new String(flow1v2, StandardCharsets.UTF_8));
}
@Test
public void testGetWhenDoesNotExist() {
final byte[] flow1v1 = fileSystemFlowProvider.getFlowContent("bucket1", "flow1", 1);
Assert.assertNull(flow1v1);
assertNull(flow1v1);
}
@Test
@ -133,13 +138,13 @@ public class TestFileSystemFlowPersistenceProvider {
createAndSaveSnapshot(fileSystemFlowProvider, bucketId, flowId, 1, "flow1v1");
createAndSaveSnapshot(fileSystemFlowProvider, bucketId, flowId, 2, "flow1v2");
Assert.assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
Assert.assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
fileSystemFlowProvider.deleteAllFlowContent(bucketId, flowId);
Assert.assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
Assert.assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
// delete a flow that doesn't exist
fileSystemFlowProvider.deleteAllFlowContent(bucketId, "some-other-flow");
@ -156,18 +161,18 @@ public class TestFileSystemFlowPersistenceProvider {
createAndSaveSnapshot(fileSystemFlowProvider, bucketId, flowId, 1, "flow1v1");
createAndSaveSnapshot(fileSystemFlowProvider, bucketId, flowId, 2, "flow1v2");
Assert.assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
Assert.assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
fileSystemFlowProvider.deleteFlowContent(bucketId, flowId, 1);
Assert.assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
Assert.assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
assertNotNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
fileSystemFlowProvider.deleteFlowContent(bucketId, flowId, 2);
Assert.assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
Assert.assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 1));
assertNull(fileSystemFlowProvider.getFlowContent(bucketId, flowId, 2));
// delete a version that doesn't exist
fileSystemFlowProvider.deleteFlowContent(bucketId, flowId, 3);
@ -195,10 +200,10 @@ public class TestFileSystemFlowPersistenceProvider {
// verify the correct snapshot file was created
final File flowSnapshotFile = new File(flowStorageDir,
bucketId + "/" + flowId + "/" + version + "/" + version + FileSystemFlowPersistenceProvider.SNAPSHOT_EXTENSION);
Assert.assertTrue(flowSnapshotFile.exists());
assertTrue(flowSnapshotFile.exists());
try (InputStream in = new FileInputStream(flowSnapshotFile)) {
Assert.assertEquals(contentString, IOUtils.toString(in, StandardCharsets.UTF_8));
assertEquals(contentString, IOUtils.toString(in, StandardCharsets.UTF_8));
}
}
}

6
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/flow/TestFlowMetadataSynchronizer.java
View File

@ -25,8 +25,8 @@ import org.apache.nifi.registry.metadata.BucketMetadata;
import org.apache.nifi.registry.metadata.FlowMetadata;
import org.apache.nifi.registry.metadata.FlowSnapshotMetadata;
import org.apache.nifi.registry.service.MetadataService;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Collections;
@ -46,7 +46,7 @@ public class TestFlowMetadataSynchronizer {
private List<BucketMetadata> metadata;
private FlowMetadataSynchronizer synchronizer;
@Before
@BeforeEach
public void setup() {
metadataService = mock(MetadataService.class);
metadataAwareflowPersistenceProvider = mock(MetadataAwareFlowPersistenceProvider.class);

21
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/flow/TestStandardFlowSnapshotContext.java
View File

@ -17,8 +17,9 @@
package org.apache.nifi.registry.provider.flow;
import org.apache.nifi.registry.flow.FlowSnapshotContext;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestStandardFlowSnapshotContext {
@ -44,14 +45,14 @@ public class TestStandardFlowSnapshotContext {
.snapshotTimestamp(timestamp)
.build();
Assert.assertEquals(bucketId, context.getBucketId());
Assert.assertEquals(bucketName, context.getBucketName());
Assert.assertEquals(flowId, context.getFlowId());
Assert.assertEquals(flowName, context.getFlowName());
Assert.assertEquals(version, context.getVersion());
Assert.assertEquals(comments, context.getComments());
Assert.assertEquals(author, context.getAuthor());
Assert.assertEquals(timestamp, context.getSnapshotTimestamp());
assertEquals(bucketId, context.getBucketId());
assertEquals(bucketName, context.getBucketName());
assertEquals(flowId, context.getFlowId());
assertEquals(flowName, context.getFlowName());
assertEquals(version, context.getVersion());
assertEquals(comments, context.getComments());
assertEquals(author, context.getAuthor());
assertEquals(timestamp, context.getSnapshotTimestamp());
}
}

8
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/flow/git/TestGitFlowPersistenceProvider.java
View File

@ -27,7 +27,7 @@ import org.eclipse.jgit.api.Git;
import org.eclipse.jgit.api.errors.GitAPIException;
import org.eclipse.jgit.lib.StoredConfig;
import org.eclipse.jgit.revwalk.RevCommit;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -40,9 +40,9 @@ import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Consumer;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class TestGitFlowPersistenceProvider {

14
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/provider/hook/TestScriptEventHookProvider.java
View File

@ -22,7 +22,7 @@ import org.apache.nifi.registry.properties.NiFiRegistryProperties;
import org.apache.nifi.registry.provider.ProviderCreationException;
import org.apache.nifi.registry.provider.ProviderFactory;
import org.apache.nifi.registry.provider.StandardProviderFactory;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import javax.sql.DataSource;
@ -30,12 +30,13 @@ import javax.sql.DataSource;
import java.net.URL;
import java.util.Properties;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
public class TestScriptEventHookProvider {
@Test(expected = ProviderCreationException.class)
@Test
public void testBadScriptProvider() {
final Properties properties = new Properties();
properties.setProperty(NiFiRegistryProperties.PROVIDERS_CONFIGURATION_FILE, "src/test/resources/provider/hook/bad-script-provider.xml");
@ -43,13 +44,16 @@ public class TestScriptEventHookProvider {
final ExtensionManager extensionManager = Mockito.mock(ExtensionManager.class);
when(extensionManager.getExtensionClassLoader(any(String.class)))
.thenReturn(new ExtensionClassLoader("/tmp", new URL[0],this.getClass().getClassLoader()));
.thenReturn(new ExtensionClassLoader("/tmp", new URL[0], this.getClass().getClassLoader()));
final DataSource dataSource = Mockito.mock(DataSource.class);
final ProviderFactory providerFactory = new StandardProviderFactory(props, extensionManager, dataSource);
providerFactory.initialize();
providerFactory.getEventHookProviders();
assertThrows(ProviderCreationException.class, () -> {
providerFactory.initialize();
providerFactory.getEventHookProviders();
});
}
}

14
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/security/authorization/TestStandardAuthorizableLookup.java
View File

@ -23,15 +23,15 @@ import org.apache.nifi.registry.security.authorization.resource.ResourceFactory;
import org.apache.nifi.registry.security.authorization.user.NiFiUser;
import org.apache.nifi.registry.security.authorization.user.StandardNiFiUser;
import org.apache.nifi.registry.service.RegistryService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatcher;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.mock;
@ -57,7 +57,7 @@ public class TestStandardAuthorizableLookup {
private Bucket bucketPublic;
private Bucket bucketNotPublic;
@Before
@BeforeEach
public void setup() {
authorizer = mock(Authorizer.class);
registryService = mock(RegistryService.class);
@ -251,7 +251,7 @@ public class TestStandardAuthorizableLookup {
final Authorizable bucketAuthorizable = authorizableLookup.getBucketAuthorizable(bucketPublic.getIdentifier());
try {
bucketAuthorizable.authorize(authorizer, action, USER_NO_PROXY_CHAIN);
Assert.fail("Should have thrown exception");
fail("Should have thrown exception");
} catch (AccessDeniedException e) {
// Should never call authorizer twice for specific bucket and top-level /buckets
verify(authorizer, times(2)).authorize(any(AuthorizationRequest.class));
@ -272,7 +272,7 @@ public class TestStandardAuthorizableLookup {
final Authorizable bucketAuthorizable = authorizableLookup.getBucketAuthorizable(bucketPublic.getIdentifier());
try {
bucketAuthorizable.authorize(authorizer, action, USER_WITH_PROXY_CHAIN);
Assert.fail("Should have thrown exception");
fail("Should have thrown exception");
} catch (UntrustedProxyException e) {
// Should call authorizer once for /proxy and then throw exception
verify(authorizer, times(1)).authorize(any(AuthorizationRequest.class));
@ -307,7 +307,7 @@ public class TestStandardAuthorizableLookup {
final Authorizable bucketAuthorizable = authorizableLookup.getBucketAuthorizable(bucketPublic.getIdentifier());
try {
bucketAuthorizable.authorize(authorizer, action, user);
Assert.fail("Should have thrown exception");
fail("Should have thrown exception");
} catch (AccessDeniedException e) {
// Should call authorizer three times for /proxy, /bucket/{id}, and /buckets
verify(authorizer, times(3)).authorize(any(AuthorizationRequest.class));

25
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/security/authorization/database/TestDatabaseAccessPolicyProvider.java
View File

@ -34,8 +34,8 @@ import org.apache.nifi.registry.security.exception.SecurityProviderCreationExcep
import org.apache.nifi.registry.security.identity.DefaultIdentityMapper;
import org.apache.nifi.registry.security.identity.IdentityMapper;
import org.apache.nifi.registry.util.StandardPropertyValue;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
@ -48,11 +48,12 @@ import java.util.Map;
import java.util.Properties;
import java.util.Set;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ -85,7 +86,7 @@ public class TestDatabaseAccessPolicyProvider extends DatabaseBaseTest {
// Class under test
private ConfigurableAccessPolicyProvider policyProvider;
@Before
@BeforeEach
public void setup() {
properties = new NiFiRegistryProperties();
identityMapper = new DefaultIdentityMapper(properties);
@ -340,14 +341,14 @@ public class TestDatabaseAccessPolicyProvider extends DatabaseBaseTest {
});
}
@Test(expected = SecurityProviderCreationException.class)
@Test
public void testOnConfiguredWhenInitialAdminNotFound() {
configure("does-not-exist", null);
assertThrows(SecurityProviderCreationException.class, () -> configure("does-not-exist", null));
}
@Test(expected = SecurityProviderCreationException.class)
@Test
public void testOnConfiguredWhenNiFiIdentityNotFound() {
configure(null, Collections.singleton("does-not-exist"));
assertThrows(SecurityProviderCreationException.class, () -> configure(null, Collections.singleton("does-not-exist")));
}
// -- Test AccessPolicy methods

14
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/security/authorization/database/TestDatabaseUserGroupProvider.java
View File

@ -27,8 +27,8 @@ import org.apache.nifi.registry.security.authorization.UserGroupProviderInitiali
import org.apache.nifi.registry.security.authorization.util.UserGroupProviderUtils;
import org.apache.nifi.registry.security.identity.DefaultIdentityMapper;
import org.apache.nifi.registry.security.identity.IdentityMapper;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
@ -39,10 +39,10 @@ import java.util.Properties;
import java.util.Set;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ -55,7 +55,7 @@ public class TestDatabaseUserGroupProvider extends DatabaseBaseTest {
private ConfigurableUserGroupProvider userGroupProvider;
@Before
@BeforeEach
public void setup() {
properties = new NiFiRegistryProperties();
identityMapper = new DefaultIdentityMapper(properties);

6
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/serialization/TestExtensionSerializer.java
View File

@ -17,8 +17,8 @@
package org.apache.nifi.registry.serialization;
import org.apache.nifi.extension.manifest.Extension;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@ -30,7 +30,7 @@ public class TestExtensionSerializer {
private Serializer<Extension> serializer;
@Before
@BeforeEach
public void setup() {
serializer = new ExtensionSerializer();
}

16
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/serialization/TestFlowContentSerializer.java
View File

@ -20,8 +20,8 @@ import org.apache.nifi.flow.ExternalControllerServiceReference;
import org.apache.nifi.registry.flow.VersionedFlowSnapshot;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.flow.VersionedProcessor;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
@ -30,17 +30,17 @@ import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.fail;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
public class TestFlowContentSerializer {
private FlowContentSerializer serializer;
@Before
@BeforeEach
public void setup() {
serializer = new FlowContentSerializer();
}

17
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/serialization/jaxb/TestJAXBVersionedProcessGroupSerializer.java
View File

@ -20,13 +20,14 @@ import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.flow.VersionedProcessor;
import org.apache.nifi.registry.serialization.SerializationException;
import org.apache.nifi.registry.serialization.VersionedSerializer;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import static org.junit.jupiter.api.Assertions.assertEquals;
public class TestJAXBVersionedProcessGroupSerializer {
@Test
@ -54,19 +55,19 @@ public class TestJAXBVersionedProcessGroupSerializer {
in.mark(1024);
final int version = serializer.readDataModelVersion(in);
Assert.assertEquals(1, version);
assertEquals(1, version);
in.reset();
final VersionedProcessGroup deserializedProcessGroup1 = serializer.deserialize(in);
Assert.assertEquals(processGroup1.getIdentifier(), deserializedProcessGroup1.getIdentifier());
Assert.assertEquals(processGroup1.getName(), deserializedProcessGroup1.getName());
assertEquals(processGroup1.getIdentifier(), deserializedProcessGroup1.getIdentifier());
assertEquals(processGroup1.getName(), deserializedProcessGroup1.getName());
Assert.assertEquals(1, deserializedProcessGroup1.getProcessors().size());
assertEquals(1, deserializedProcessGroup1.getProcessors().size());
final VersionedProcessor deserializedProcessor1 = deserializedProcessGroup1.getProcessors().iterator().next();
Assert.assertEquals(processor1.getIdentifier(), deserializedProcessor1.getIdentifier());
Assert.assertEquals(processor1.getName(), deserializedProcessor1.getName());
assertEquals(processor1.getIdentifier(), deserializedProcessor1.getIdentifier());
assertEquals(processor1.getName(), deserializedProcessor1.getName());
}
}

172
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/service/TestRegistryService.java
View File

@ -16,6 +16,8 @@
*/
package org.apache.nifi.registry.service;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.flow.VersionedProcessor;
import org.apache.nifi.registry.bucket.Bucket;
import org.apache.nifi.registry.db.entity.BucketEntity;
import org.apache.nifi.registry.db.entity.FlowEntity;
@ -29,14 +31,11 @@ import org.apache.nifi.registry.flow.FlowPersistenceProvider;
import org.apache.nifi.registry.flow.VersionedFlow;
import org.apache.nifi.registry.flow.VersionedFlowSnapshot;
import org.apache.nifi.registry.flow.VersionedFlowSnapshotMetadata;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.flow.VersionedProcessor;
import org.apache.nifi.registry.serialization.FlowContent;
import org.apache.nifi.registry.serialization.FlowContentSerializer;
import org.apache.nifi.registry.service.alias.RegistryUrlAliasService;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
@ -57,9 +56,10 @@ import java.util.Optional;
import java.util.Set;
import java.util.SortedSet;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.anyString;
@ -81,7 +81,7 @@ public class TestRegistryService {
private RegistryService registryService;
@Before
@BeforeEach
public void setup() {
metadataService = mock(MetadataService.class);
flowPersistenceProvider = mock(FlowPersistenceProvider.class);
@ -119,7 +119,7 @@ public class TestRegistryService {
assertEquals(bucket.getDescription(), createdBucket.getDescription());
}
@Test(expected = IllegalStateException.class)
@Test
public void testCreateBucketWithSameName() {
final Bucket bucket = new Bucket();
bucket.setIdentifier("b2");
@ -134,14 +134,14 @@ public class TestRegistryService {
when(metadataService.getBucketsByName(bucket.getName())).thenReturn(Collections.singletonList(existingBucket));
// should throw exception since a bucket with the same name exists
registryService.createBucket(bucket);
assertThrows(IllegalStateException.class, () -> registryService.createBucket(bucket));
}
@Test(expected = ConstraintViolationException.class)
@Test
public void testCreateBucketWithMissingName() {
final Bucket bucket = new Bucket();
when(metadataService.getBucketsByName(bucket.getName())).thenReturn(Collections.emptyList());
registryService.createBucket(bucket);
assertThrows(ConstraintViolationException.class, () -> registryService.createBucket(bucket));
}
@Test
@ -162,33 +162,33 @@ public class TestRegistryService {
assertEquals(existingBucket.getCreated().getTime(), bucket.getCreatedTimestamp());
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testGetBucketDoesNotExist() {
when(metadataService.getBucketById(any(String.class))).thenReturn(null);
registryService.getBucket("does-not-exist");
assertThrows(ResourceNotFoundException.class, () -> registryService.getBucket("does-not-exist"));
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testUpdateBucketWithoutId() {
final Bucket bucket = new Bucket();
bucket.setName("My Bucket");
bucket.setDescription("This is my bucket.");
registryService.updateBucket(bucket);
assertThrows(IllegalArgumentException.class, () -> registryService.updateBucket(bucket));
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testUpdateBucketDoesNotExist() {
final Bucket bucket = new Bucket();
bucket.setIdentifier("b1");
bucket.setName("My Bucket");
bucket.setDescription("This is my bucket.");
registryService.updateBucket(bucket);
assertThrows(ResourceNotFoundException.class, () -> registryService.updateBucket(bucket));
when(metadataService.getBucketById(any(String.class))).thenReturn(null);
registryService.updateBucket(bucket);
assertThrows(ResourceNotFoundException.class, () -> registryService.updateBucket(bucket));
}
@Test(expected = IllegalStateException.class)
@Test
public void testUpdateBucketWithSameNameAsExistingBucket() {
final BucketEntity bucketToUpdate = new BucketEntity();
bucketToUpdate.setId("b1");
@ -212,7 +212,7 @@ public class TestRegistryService {
updatedBucket.setName("My Bucket #2");
updatedBucket.setDescription(bucketToUpdate.getDescription());
registryService.updateBucket(updatedBucket);
assertThrows(IllegalStateException.class, () -> registryService.updateBucket(updatedBucket));
}
@Test
@ -262,11 +262,11 @@ public class TestRegistryService {
assertEquals(bucketToUpdate.getDescription(), result.getDescription());
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testDeleteBucketDoesNotExist() {
final String bucketId = "b1";
when(metadataService.getBucketById(bucketId)).thenReturn(null);
registryService.deleteBucket(bucketId);
assertThrows(ResourceNotFoundException.class, () -> registryService.deleteBucket(bucketId));
}
@Test
@ -300,13 +300,13 @@ public class TestRegistryService {
// ---------------------- Test VersionedFlow methods ---------------------------------------------
@Test(expected = ConstraintViolationException.class)
@Test
public void testCreateFlowInvalid() {
final VersionedFlow versionedFlow = new VersionedFlow();
registryService.createFlow("b1", versionedFlow);
assertThrows(ConstraintViolationException.class, () -> registryService.createFlow("b1", versionedFlow));
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testCreateFlowBucketDoesNotExist() {
when(metadataService.getBucketById(any(String.class))).thenReturn(null);
@ -316,10 +316,10 @@ public class TestRegistryService {
versionedFlow.setName("My Flow");
versionedFlow.setBucketIdentifier("b1");
registryService.createFlow(versionedFlow.getBucketIdentifier(), versionedFlow);
assertThrows(ResourceNotFoundException.class, () -> registryService.createFlow(versionedFlow.getBucketIdentifier(), versionedFlow));
}
@Test(expected = IllegalStateException.class)
@Test
public void testCreateFlowWithSameName() {
final BucketEntity existingBucket = new BucketEntity();
existingBucket.setId("b1");
@ -345,7 +345,7 @@ public class TestRegistryService {
versionedFlow.setName(flowWithSameName.getName());
versionedFlow.setBucketIdentifier("b1");
registryService.createFlow(versionedFlow.getBucketIdentifier(), versionedFlow);
assertThrows(IllegalStateException.class, () -> registryService.createFlow(versionedFlow.getBucketIdentifier(), versionedFlow));
}
@Test
@ -376,16 +376,16 @@ public class TestRegistryService {
assertEquals(versionedFlow.getDescription(), createdFlow.getDescription());
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testGetFlowDoesNotExist() {
when(metadataService.getFlowById(any(String.class))).thenReturn(null);
registryService.getFlow("bucket1","flow1");
assertThrows(ResourceNotFoundException.class, () -> registryService.getFlow("bucket1", "flow1"));
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testGetFlowDirectDoesNotExist() {
when(metadataService.getFlowById(any(String.class))).thenReturn(null);
registryService.getFlow("flow1");
assertThrows(ResourceNotFoundException.class , () -> registryService.getFlow("flow1"));
}
@Test
@ -449,10 +449,10 @@ public class TestRegistryService {
assertEquals(flowEntity.getModified().getTime(), versionedFlow.getModifiedTimestamp());
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testGetFlowsByBucketDoesNotExist() {
when(metadataService.getBucketById(any(String.class))).thenReturn(null);
registryService.getFlows("b1");
assertThrows(ResourceNotFoundException.class, () -> registryService.getFlows("b1"));
}
@Test
@ -492,13 +492,13 @@ public class TestRegistryService {
assertEquals(2, allFlows.size());
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testUpdateFlowWithoutId() {
final VersionedFlow versionedFlow = new VersionedFlow();
registryService.updateFlow(versionedFlow);
assertThrows(IllegalArgumentException.class, () -> registryService.updateFlow(versionedFlow));
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testUpdateFlowDoesNotExist() {
final VersionedFlow versionedFlow = new VersionedFlow();
versionedFlow.setBucketIdentifier("b1");
@ -506,10 +506,10 @@ public class TestRegistryService {
when(metadataService.getFlowById(versionedFlow.getIdentifier())).thenReturn(null);
registryService.updateFlow(versionedFlow);
assertThrows(ResourceNotFoundException.class, () -> registryService.updateFlow(versionedFlow));
}
@Test(expected = IllegalStateException.class)
@Test
public void testUpdateFlowWithSameNameAsExistingFlow() {
final BucketEntity existingBucket = new BucketEntity();
existingBucket.setId("b1");
@ -544,7 +544,7 @@ public class TestRegistryService {
versionedFlow.setBucketIdentifier(existingBucket.getId());
versionedFlow.setName(otherFlow.getName());
registryService.updateFlow(versionedFlow);
assertThrows(IllegalStateException.class, () -> registryService.updateFlow(versionedFlow));
}
@Test
@ -590,10 +590,10 @@ public class TestRegistryService {
assertEquals(flowToUpdate.getCreated().getTime(), updatedFlow.getCreatedTimestamp());
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testDeleteFlowDoesNotExist() {
when(metadataService.getFlowById(any(String.class))).thenReturn(null);
registryService.deleteFlow("b1", "flow1");
assertThrows(ResourceNotFoundException.class, () -> registryService.deleteFlow("b1", "flow1"));
}
@Test
@ -647,43 +647,43 @@ public class TestRegistryService {
return snapshot;
}
@Test(expected = ConstraintViolationException.class)
@Test
public void testCreateSnapshotInvalidMetadata() {
final VersionedFlowSnapshot snapshot = createSnapshot();
snapshot.getSnapshotMetadata().setFlowIdentifier(null);
registryService.createFlowSnapshot(snapshot);
assertThrows(ConstraintViolationException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = ConstraintViolationException.class)
@Test
public void testCreateSnapshotInvalidFlowContents() {
final VersionedFlowSnapshot snapshot = createSnapshot();
snapshot.setFlowContents(null);
registryService.createFlowSnapshot(snapshot);
assertThrows(ConstraintViolationException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = ConstraintViolationException.class)
@Test
public void testCreateSnapshotNullMetadata() {
final VersionedFlowSnapshot snapshot = createSnapshot();
snapshot.setSnapshotMetadata(null);
registryService.createFlowSnapshot(snapshot);
assertThrows(ConstraintViolationException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = ConstraintViolationException.class)
@Test
public void testCreateSnapshotNullFlowContents() {
final VersionedFlowSnapshot snapshot = createSnapshot();
snapshot.setFlowContents(null);
registryService.createFlowSnapshot(snapshot);
assertThrows(ConstraintViolationException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testCreateSnapshotBucketDoesNotExist() {
when(metadataService.getBucketById(any(String.class))).thenReturn(null);
final VersionedFlowSnapshot snapshot = createSnapshot();
registryService.createFlowSnapshot(snapshot);
assertThrows(ResourceNotFoundException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testCreateSnapshotFlowDoesNotExist() {
final VersionedFlowSnapshot snapshot = createSnapshot();
@ -697,10 +697,10 @@ public class TestRegistryService {
when(metadataService.getFlowById(snapshot.getSnapshotMetadata().getFlowIdentifier())).thenReturn(null);
registryService.createFlowSnapshot(snapshot);
assertThrows(ResourceNotFoundException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = IllegalStateException.class)
@Test
public void testCreateSnapshotVersionAlreadyExists() {
final VersionedFlowSnapshot snapshot = createSnapshot();
@ -734,10 +734,10 @@ public class TestRegistryService {
final List<FlowSnapshotEntity> existingSnapshots = Arrays.asList(existingSnapshot);
when(metadataService.getSnapshots(existingFlow.getId())).thenReturn(existingSnapshots);
registryService.createFlowSnapshot(snapshot);
assertThrows(IllegalStateException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = IllegalStateException.class)
@Test
public void testCreateSnapshotVersionNotNextVersion() {
final VersionedFlowSnapshot snapshot = createSnapshot();
@ -770,7 +770,7 @@ public class TestRegistryService {
// set the version to something that is not the next one-up version
snapshot.getSnapshotMetadata().setVersion(100);
registryService.createFlowSnapshot(snapshot);
assertThrows(IllegalStateException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test
@ -808,7 +808,7 @@ public class TestRegistryService {
verify(metadataService, times(1)).createFlowSnapshot(any(FlowSnapshotEntity.class));
}
@Test(expected = IllegalStateException.class)
@Test
public void testCreateFirstSnapshotWithBadVersion() {
final VersionedFlowSnapshot snapshot = createSnapshot();
@ -833,10 +833,10 @@ public class TestRegistryService {
// set the first version to something other than 1
snapshot.getSnapshotMetadata().setVersion(100);
registryService.createFlowSnapshot(snapshot);
assertThrows(IllegalStateException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testCreateFirstSnapshotWithZeroVersion() {
final VersionedFlowSnapshot snapshot = createSnapshot();
@ -861,7 +861,7 @@ public class TestRegistryService {
// set the first version to something other than 1
snapshot.getSnapshotMetadata().setVersion(0);
registryService.createFlowSnapshot(snapshot);
assertThrows(IllegalArgumentException.class, () -> registryService.createFlowSnapshot(snapshot));
}
@Test
@ -1086,24 +1086,21 @@ public class TestRegistryService {
when(metadataService.getLatestSnapshot(existingFlow.getId())).thenReturn(null);
try {
registryService.getLatestFlowSnapshotMetadata(existingBucket.getId(), existingFlow.getId());
Assert.fail("Should have thrown exception");
} catch (ResourceNotFoundException e) {
assertEquals("The specified flow ID has no versions", e.getMessage());
}
ResourceNotFoundException e = assertThrows(ResourceNotFoundException.class, () -> registryService.getLatestFlowSnapshotMetadata(existingBucket.getId(), existingFlow.getId()));
assertEquals("The specified flow ID has no versions", e.getMessage());
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testGetSnapshotDoesNotExistInMetadataProvider() {
final String bucketId = "b1";
final String flowId = "flow1";
final Integer version = 1;
when(metadataService.getFlowSnapshot(flowId, version)).thenReturn(null);
registryService.getFlowSnapshot(bucketId, flowId, version);
assertThrows(ResourceNotFoundException.class, () -> registryService.getFlowSnapshot(bucketId, flowId, version));
}
@Test(expected = IllegalStateException.class)
@Test
public void testGetSnapshotDoesNotExistInPersistenceProvider() {
final BucketEntity existingBucket = createBucketEntity("b1");
final FlowEntity existingFlow = createFlowEntity(existingBucket.getId());
@ -1126,7 +1123,7 @@ public class TestRegistryService {
existingSnapshot.getVersion()
)).thenReturn(null);
registryService.getFlowSnapshot(existingBucket.getId(), existingSnapshot.getFlowId(), existingSnapshot.getVersion());
assertThrows(IllegalStateException.class, () -> registryService.getFlowSnapshot(existingBucket.getId(), existingSnapshot.getFlowId(), existingSnapshot.getVersion()));
}
@Test
@ -1180,13 +1177,13 @@ public class TestRegistryService {
assertNotNull(bucket);
}
@Test(expected = ResourceNotFoundException.class)
@Test
public void testDeleteSnapshotDoesNotExist() {
final String bucketId = "b1";
final String flowId = "flow1";
final Integer version = 1;
when(metadataService.getFlowSnapshot(flowId, version)).thenReturn(null);
registryService.deleteFlowSnapshot(bucketId, flowId, version);
assertThrows(ResourceNotFoundException.class, () -> registryService.deleteFlowSnapshot(bucketId, flowId, version));
}
@Test
@ -1260,14 +1257,14 @@ public class TestRegistryService {
final VersionedProcessGroup pgB = createVersionedProcessGroupB();
when(flowContentSerializer.readDataModelVersion(any(InputStream.class))).thenReturn(2);
when(flowContentSerializer.isProcessGroupVersion(eq(2))).thenReturn(true);
when(flowContentSerializer.deserializeProcessGroup(eq(2),any())).thenReturn(pgA, pgB);
when(flowContentSerializer.deserializeProcessGroup(eq(2), any())).thenReturn(pgA, pgB);
final VersionedFlowDifference diff = registryService.getFlowDiff(
"bucketIdentifier", "flowIdentifier", 1, 2);
assertNotNull(diff);
Optional<ComponentDifferenceGroup> removedComponent = diff.getComponentDifferenceGroups().stream()
.filter(p->p.getComponentId().equals("ID-pg1")).findFirst();
.filter(p -> p.getComponentId().equals("ID-pg1")).findFirst();
assertTrue(removedComponent.isPresent());
assertTrue(removedComponent.get().getDifferences().iterator().next().getDifferenceType().equals("COMPONENT_REMOVED"));
@ -1283,20 +1280,20 @@ public class TestRegistryService {
final VersionedProcessGroup pgB = createVersionedProcessGroupB();
when(flowContentSerializer.readDataModelVersion(any(InputStream.class))).thenReturn(2);
when(flowContentSerializer.isProcessGroupVersion(eq(2))).thenReturn(true);
when(flowContentSerializer.deserializeProcessGroup(eq(2),any())).thenReturn(pgA, pgB);
when(flowContentSerializer.deserializeProcessGroup(eq(2), any())).thenReturn(pgA, pgB);
// getFlowDiff orders the changes in ascending order of version number regardless of param order
final VersionedFlowDifference diff = registryService.getFlowDiff(
"bucketIdentifier", "flowIdentifier", 2,1);
"bucketIdentifier", "flowIdentifier", 2, 1);
assertNotNull(diff);
Optional<ComponentDifferenceGroup> nameChangedComponent = diff.getComponentDifferenceGroups().stream()
.filter(p->p.getComponentId().equals("ProcessorFirstV1")).findFirst();
.filter(p -> p.getComponentId().equals("ProcessorFirstV1")).findFirst();
assertTrue(nameChangedComponent.isPresent());
ComponentDifference nameChangeDifference = nameChangedComponent.get().getDifferences().stream()
.filter(d-> d.getDifferenceType().equals("NAME_CHANGED")).findFirst().get();
.filter(d -> d.getDifferenceType().equals("NAME_CHANGED")).findFirst().get();
assertEquals("ProcessorFirstV1", nameChangeDifference.getValueA());
assertEquals("ProcessorFirstV2", nameChangeDifference.getValueB());
@ -1310,22 +1307,23 @@ public class TestRegistryService {
return root;
}
private VersionedProcessGroup createProcessGroup(String identifier){
private VersionedProcessGroup createProcessGroup(String identifier) {
VersionedProcessGroup processGroup = new VersionedProcessGroup();
processGroup.setIdentifier(identifier);
return processGroup;
}
private VersionedProcessGroup createVersionedProcessGroupB() {
VersionedProcessGroup updated = createVersionedProcessGroupA();
// remove a process group
updated.getProcessGroups().removeIf(pg->pg.getIdentifier().equals("ID-pg1"));
updated.getProcessGroups().removeIf(pg -> pg.getIdentifier().equals("ID-pg1"));
// change the name of a processor
updated.getProcessors().stream().forEach(p->p.setPenaltyDuration(p.getName().equals("ProcessorFirstV1") ? "1" : "2"));
updated.getProcessors().stream().forEach(p->p.setName(p.getName().equals("ProcessorFirstV1") ? "ProcessorFirstV2" : p.getName()));
updated.getProcessors().stream().forEach(p -> p.setPenaltyDuration(p.getName().equals("ProcessorFirstV1") ? "1" : "2"));
updated.getProcessors().stream().forEach(p -> p.setName(p.getName().equals("ProcessorFirstV1") ? "ProcessorFirstV2" : p.getName()));
return updated;
}
private VersionedProcessor createVersionedProcessor(String name){
private VersionedProcessor createVersionedProcessor(String name) {
VersionedProcessor processor = new VersionedProcessor();
processor.setName(name);
processor.setIdentifier(name);

14
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/service/alias/RegistryUrlAliasServiceTest.java
View File

@ -17,12 +17,14 @@
package org.apache.nifi.registry.service.alias;
import org.apache.nifi.registry.url.aliaser.generated.Alias;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.Collections;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class RegistryUrlAliasServiceTest {
private static Alias createAlias(String internal, String external) {
@ -42,9 +44,9 @@ public class RegistryUrlAliasServiceTest {
assertEquals(url, aliaser.getInternal(url));
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testMalformedExternal() {
new RegistryUrlAliasService(Collections.singletonList(createAlias("https://registry.com:18080", "registry.com:18080")));
assertThrows(IllegalArgumentException.class, () -> new RegistryUrlAliasService(Collections.singletonList(createAlias("https://registry.com:18080", "registry.com:18080"))));
}
@Test
@ -160,12 +162,12 @@ public class RegistryUrlAliasServiceTest {
assertEquals(external, aliaser.getExternal(internal2));
}
@Test(expected = IllegalArgumentException.class)
@Test
public void testDuplicateInternalTokens() {
String internal = "THIS_NIFI_REGISTRY";
String external1 = "http://localhost:18080";
String external2 = "http://localhost:18081";
new RegistryUrlAliasService(Arrays.asList(createAlias(internal, external1), createAlias(internal, external2)));
assertThrows(IllegalArgumentException.class, () -> new RegistryUrlAliasService(Arrays.asList(createAlias(internal, external1), createAlias(internal, external2))));
}
}

6
nifi-registry/nifi-registry-core/nifi-registry-framework/src/test/java/org/apache/nifi/registry/service/extension/docs/TestHtmlExtensionDocWriter.java
View File

@ -25,8 +25,8 @@ import org.apache.nifi.registry.serialization.ExtensionSerializer;
import org.apache.nifi.registry.serialization.Serializer;
import org.apache.nifi.registry.serialization.jackson.ObjectMapperProvider;
import org.apache.nifi.registry.service.mapper.ExtensionMappings;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.File;
@ -43,7 +43,7 @@ public class TestHtmlExtensionDocWriter {
private ExtensionDocWriter docWriter;
private Serializer<Extension> extensionSerializer;
@Before
@BeforeEach
public void setup() {
docWriter = new HtmlExtensionDocWriter();
extensionSerializer = new ExtensionSerializer();

8
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/BucketsIT.java
View File

@ -18,7 +18,7 @@ package org.apache.nifi.registry.web.api;
import org.apache.nifi.registry.bucket.Bucket;
import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.test.annotation.IfProfileValue;
import org.springframework.test.context.jdbc.Sql;
@ -30,9 +30,9 @@ import javax.ws.rs.core.Response;
import java.util.UUID;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertBucketsEqual;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class BucketsIT extends UnsecuredITBase {

24
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/DBFlowStorageIT.java
View File

@ -16,6 +16,7 @@
*/
package org.apache.nifi.registry.web.api;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.registry.NiFiRegistryTestApiApplication;
import org.apache.nifi.registry.bucket.Bucket;
import org.apache.nifi.registry.client.NiFiRegistryClient;
@ -25,25 +26,24 @@ import org.apache.nifi.registry.client.impl.JerseyNiFiRegistryClient;
import org.apache.nifi.registry.flow.VersionedFlow;
import org.apache.nifi.registry.flow.VersionedFlowSnapshot;
import org.apache.nifi.registry.flow.VersionedFlowSnapshotMetadata;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import java.io.IOException;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.fail;
@RunWith(SpringRunner.class)
@ExtendWith(SpringExtension.class)
@SpringBootTest(
classes = NiFiRegistryTestApiApplication.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
@ -55,7 +55,7 @@ public class DBFlowStorageIT extends IntegrationTestBase {
private NiFiRegistryClient client;
@Before
@BeforeEach
public void setup() throws IOException {
final String baseUrl = createBaseURL();
LOGGER.info("Using base url = " + baseUrl);
@ -72,7 +72,7 @@ public class DBFlowStorageIT extends IntegrationTestBase {
this.client = client;
}
@After
@AfterEach
public void teardown() {
try {
client.close();

46
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/FlowsIT.java
View File

@ -16,15 +16,13 @@
*/
package org.apache.nifi.registry.web.api;
import java.io.File;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.registry.bucket.BucketItemType;
import org.apache.nifi.registry.flow.VersionedFlow;
import org.apache.nifi.registry.flow.VersionedFlowSnapshot;
import org.apache.nifi.registry.flow.VersionedFlowSnapshotMetadata;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.junit.Assert;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.test.annotation.IfProfileValue;
import org.springframework.test.context.jdbc.Sql;
@ -34,15 +32,17 @@ import javax.ws.rs.client.Entity;
import javax.ws.rs.client.WebTarget;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.io.File;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertBucketsEqual;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertFlowSnapshotMetadataEqual;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertFlowSnapshotsEqual;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertFlowsEqual;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
@Sql(executionPhase = Sql.ExecutionPhase.BEFORE_TEST_METHOD, scripts = {"classpath:db/clearDB.sql", "classpath:db/FlowsIT.sql"})
public class FlowsIT extends UnsecuredITBase {
@ -72,7 +72,7 @@ public class FlowsIT extends UnsecuredITBase {
// NOTE: The tests that seed the DB directly from SQL end up with different results for the timestamp depending on
// which DB is used, so for now these types of tests only run against H2.
@Test
@IfProfileValue(name="current.database.is.h2", value="true")
@IfProfileValue(name = "current.database.is.h2", value = "true")
public void testGetFlows() throws Exception {
// Given: a few buckets and flows have been populated in the DB (see FlowsIT.sql)
@ -365,7 +365,7 @@ public class FlowsIT extends UnsecuredITBase {
// NOTE: The tests that seed the DB directly from SQL end up with different results for the timestamp depending on
// which DB is used, so for now these types of tests only run against H2.
@Test
@IfProfileValue(name="current.database.is.h2", value="true")
@IfProfileValue(name = "current.database.is.h2", value = "true")
public void testGetFlowVersions() throws Exception {
// Given: a bucket "1" with flow "1" with existing snapshots has been populated in the DB (see FlowsIT.sql)
@ -532,17 +532,15 @@ public class FlowsIT extends UnsecuredITBase {
// saving the flow to bucket 1 should not work because there is a flow with the same name
flow.setBucketIdentifier("1");
try {
client.target(createURL("buckets/1/flows"))
.resolveTemplate("bucketId", bucketId)
.request()
.post(Entity.entity(flow, MediaType.APPLICATION_JSON), VersionedFlow.class);
Assert.fail("Should have thrown exception");
} catch (WebApplicationException e) {
final String errorMessage = e.getResponse().readEntity(String.class);
Assert.assertEquals("A versioned flow with the same name already exists in the selected bucket", errorMessage);
}
WebApplicationException e = assertThrows(WebApplicationException.class, () -> client.target(createURL("buckets/1/flows"))
.resolveTemplate("bucketId", bucketId)
.request()
.post(Entity.entity(flow, MediaType.APPLICATION_JSON), VersionedFlow.class));
final String errorMessage = e.getResponse().readEntity(String.class);
assertEquals("A versioned flow with the same name already exists in the selected bucket", errorMessage);
}
@ -606,10 +604,10 @@ public class FlowsIT extends UnsecuredITBase {
// GET the versioned Flow that was just imported
final VersionedFlowSnapshotMetadata[] versionedFlowSnapshots = client
.target(createURL("buckets/{bucketId}/flows/{flowId}/versions"))
.resolveTemplate("bucketId", bucketId)
.resolveTemplate("flowId", flowId)
.request().get(VersionedFlowSnapshotMetadata[].class);
.target(createURL("buckets/{bucketId}/flows/{flowId}/versions"))
.resolveTemplate("bucketId", bucketId)
.resolveTemplate("flowId", flowId)
.request().get(VersionedFlowSnapshotMetadata[].class);
assertNotNull(versionedFlowSnapshots);
assertEquals(2, versionedFlowSnapshots.length);
assertFlowSnapshotMetadataEqual(importedFlowSnapshot.getSnapshotMetadata(), versionedFlowSnapshots[0], true);

6
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/NoRevisionsIT.java
View File

@ -21,7 +21,7 @@ import org.apache.nifi.registry.flow.VersionedFlow;
import org.apache.nifi.registry.flow.VersionedFlowSnapshot;
import org.apache.nifi.registry.flow.VersionedFlowSnapshotMetadata;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.MediaType;
@ -31,8 +31,8 @@ import java.util.UUID;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertBucketsEqual;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertFlowSnapshotsEqual;
import static org.apache.nifi.registry.web.api.IntegrationTestUtils.assertFlowsEqual;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
public class NoRevisionsIT extends UnsecuredNoRevisionsITBase {

25
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/SecureDatabaseIT.java
View File

@ -30,27 +30,26 @@ import org.apache.nifi.registry.client.impl.JerseyNiFiRegistryClient;
import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.apache.nifi.registry.security.authorization.RequestAction;
import org.apache.nifi.registry.security.authorization.resource.ResourceFactory;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
@RunWith(SpringRunner.class)
@ExtendWith(SpringExtension.class)
@SpringBootTest(
classes = NiFiRegistryTestApiApplication.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
@ -66,22 +65,22 @@ public class SecureDatabaseIT extends IntegrationTestBase {
private NiFiRegistryClient client;
@Before
@BeforeEach
public void setup() {
final String baseUrl = createBaseURL();
LOGGER.info("Using base url = " + baseUrl);
final NiFiRegistryClientConfig clientConfig = createClientConfig(baseUrl);
Assert.assertNotNull(clientConfig);
assertNotNull(clientConfig);
final NiFiRegistryClient client = new JerseyNiFiRegistryClient.Builder()
.config(clientConfig)
.build();
Assert.assertNotNull(client);
assertNotNull(client);
this.client = client;
}
@After
@AfterEach
public void teardown() {
try {
client.close();

13
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/SecureFileIT.java
View File

@ -22,22 +22,21 @@ import org.apache.nifi.registry.authorization.Tenant;
import org.apache.nifi.registry.authorization.User;
import org.apache.nifi.registry.authorization.UserGroup;
import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import javax.ws.rs.client.Entity;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
/**
* Deploy the Web API Application using an embedded Jetty Server for local integration testing, with the follow characteristics:
@ -47,7 +46,7 @@ import static org.junit.Assert.assertNotNull;
* - The database is embed H2 using volatile (in-memory) persistence
* - Custom SQL is clearing the DB before each test method by default, unless method overrides this behavior
*/
@RunWith(SpringRunner.class)
@ExtendWith(SpringExtension.class)
@SpringBootTest(
classes = NiFiRegistryTestApiApplication.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,

18
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/SecureKerberosIT.java
View File

@ -19,9 +19,9 @@ package org.apache.nifi.registry.web.api;
import org.apache.commons.lang3.StringUtils;
import org.apache.nifi.registry.NiFiRegistryTestApiApplication;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.skyscreamer.jsonassert.JSONAssert;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
@ -33,7 +33,7 @@ import org.springframework.security.authentication.BadCredentialsException;
import org.springframework.security.kerberos.authentication.KerberosTicketValidation;
import org.springframework.security.kerberos.authentication.KerberosTicketValidator;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import javax.ws.rs.core.Response;
import java.io.UnsupportedEncodingException;
@ -41,9 +41,9 @@ import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Base64;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Deploy the Web API Application using an embedded Jetty Server for local integration testing, with the follow characteristics:
@ -53,7 +53,7 @@ import static org.junit.Assert.assertTrue;
* - The database is embed H2 using volatile (in-memory) persistence
* - Custom SQL is clearing the DB before each test method by default, unless method overrides this behavior
*/
@RunWith(SpringRunner.class)
@ExtendWith(SpringExtension.class)
@SpringBootTest(
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
properties = "spring.profiles.include=ITSecureKerberos")
@ -102,7 +102,7 @@ public class SecureKerberosIT extends IntegrationTestBase {
private String adminAuthToken;
@Before
@BeforeEach
public void generateAuthToken() {
String validTicket = new String(Base64.getEncoder().encode(validKerberosTicket.getBytes(Charset.forName("UTF-8"))));
final String token = client

25
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/SecureNiFiRegistryClientIT.java
View File

@ -16,6 +16,7 @@
*/
package org.apache.nifi.registry.web.api;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.registry.NiFiRegistryTestApiApplication;
import org.apache.nifi.registry.authorization.CurrentUser;
import org.apache.nifi.registry.authorization.Permissions;
@ -36,19 +37,17 @@ import org.apache.nifi.registry.client.impl.request.ProxiedEntityRequestConfig;
import org.apache.nifi.registry.flow.VersionedFlow;
import org.apache.nifi.registry.flow.VersionedFlowSnapshot;
import org.apache.nifi.registry.flow.VersionedFlowSnapshotMetadata;
import org.apache.nifi.flow.VersionedProcessGroup;
import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import javax.ws.rs.ForbiddenException;
import java.io.IOException;
@ -60,7 +59,7 @@ import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
@RunWith(SpringRunner.class)
@ExtendWith(SpringExtension.class)
@SpringBootTest(
classes = NiFiRegistryTestApiApplication.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
@ -76,22 +75,22 @@ public class SecureNiFiRegistryClientIT extends IntegrationTestBase {
private NiFiRegistryClient client;
@Before
@BeforeEach
public void setup() {
final String baseUrl = createBaseURL();
LOGGER.info("Using base url = " + baseUrl);
final NiFiRegistryClientConfig clientConfig = createClientConfig(baseUrl);
Assert.assertNotNull(clientConfig);
assertNotNull(clientConfig);
final NiFiRegistryClient client = new JerseyNiFiRegistryClient.Builder()
.config(clientConfig)
.build();
Assert.assertNotNull(client);
assertNotNull(client);
this.client = client;
}
@After
@AfterEach
public void teardown() {
try {
client.close();
@ -129,7 +128,7 @@ public class SecureNiFiRegistryClientIT extends IntegrationTestBase {
assertNotNull(createdBucket.getRevision());
final List<Bucket> buckets = bucketClient.getAll();
Assert.assertEquals(4, buckets.size());
assertEquals(4, buckets.size());
buckets.forEach(b -> assertNotNull(b.getRevision()));
final VersionedFlow flow = new VersionedFlow();

29
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/SecureProxyIT.java
View File

@ -25,27 +25,26 @@ import org.apache.nifi.registry.client.RequestConfig;
import org.apache.nifi.registry.client.UserClient;
import org.apache.nifi.registry.client.impl.JerseyNiFiRegistryClient;
import org.apache.nifi.registry.client.impl.request.ProxiedEntityRequestConfig;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.skyscreamer.jsonassert.JSONAssert;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import javax.ws.rs.core.Response;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@RunWith(SpringRunner.class)
@ExtendWith(SpringExtension.class)
@SpringBootTest(
classes = NiFiRegistryTestApiApplication.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
@ -64,22 +63,22 @@ public class SecureProxyIT extends IntegrationTestBase {
private NiFiRegistryClient registryClient;
@Before
@BeforeEach
public void setup() {
final String baseUrl = createBaseURL();
LOGGER.info("Using base url = " + baseUrl);
final NiFiRegistryClientConfig clientConfig = createClientConfig(baseUrl);
Assert.assertNotNull(clientConfig);
assertNotNull(clientConfig);
final NiFiRegistryClient client = new JerseyNiFiRegistryClient.Builder()
.config(clientConfig)
.build();
Assert.assertNotNull(client);
assertNotNull(client);
this.registryClient = client;
}
@After
@AfterEach
public void teardown() {
try {
registryClient.close();

6
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/TenantResourceTest.java
View File

@ -24,8 +24,8 @@ import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.apache.nifi.registry.revision.web.ClientIdParameter;
import org.apache.nifi.registry.revision.web.LongParameter;
import org.apache.nifi.registry.web.service.ServiceFacade;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import javax.servlet.http.HttpServletRequest;
import java.net.URI;
@ -43,7 +43,7 @@ public class TenantResourceTest {
private EventService eventService;
private ServiceFacade serviceFacade;
@Before
@BeforeEach
public void setUp() {
eventService = mock(EventService.class);
serviceFacade = mock(ServiceFacade.class);

40
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/api/UnsecuredNiFiRegistryClientIT.java
View File

@ -74,9 +74,9 @@ import org.apache.nifi.registry.revision.entity.RevisionInfo;
import org.apache.nifi.registry.util.FileUtils;
import org.bouncycastle.util.encoders.Hex;
import org.glassfish.jersey.media.multipart.MultiPartFeature;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@ -103,11 +103,12 @@ import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;
/**
* Test all basic functionality of JerseyNiFiRegistryClient.
@ -120,7 +121,7 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
private NiFiRegistryClient client;
@Before
@BeforeEach
public void setup() {
final String baseUrl = createBaseURL();
LOGGER.info("Using base url = " + baseUrl);
@ -149,7 +150,7 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
}
}
@After
@AfterEach
public void teardown() {
try {
client.close();
@ -183,7 +184,7 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
final int numBuckets = 10;
final List<Bucket> createdBuckets = new ArrayList<>();
for (int i=0; i < numBuckets; i++) {
for (int i = 0; i < numBuckets; i++) {
final Bucket createdBucket = createBucket(bucketClient, i);
LOGGER.info("Created bucket # " + i + " with id " + createdBucket.getIdentifier());
createdBuckets.add(createdBucket);
@ -346,13 +347,8 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
assertEquals(2, latestMetadata.getVersion());
// get latest metadata that doesn't exist
try {
snapshotClient.getLatestMetadata(snapshotFlow.getBucketIdentifier(), "DOES-NOT-EXIST");
fail("Should have thrown exception");
} catch (NiFiRegistryException nfe) {
assertEquals("Error retrieving latest snapshot metadata: The specified flow ID does not exist in this bucket.", nfe.getMessage());
}
NiFiRegistryException nfe = assertThrows(NiFiRegistryException.class, () -> snapshotClient.getLatestMetadata(snapshotFlow.getBucketIdentifier(), "DOES-NOT-EXIST"));
assertEquals("Error retrieving latest snapshot metadata: The specified flow ID does not exist in this bucket.", nfe.getMessage());
// get latest metadata without bucket
final VersionedFlowSnapshotMetadata latestMetadataWithoutBucket = snapshotClient.getLatestMetadata(snapshotFlow.getIdentifier());
assertNotNull(latestMetadataWithoutBucket);
@ -708,7 +704,7 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
assertNotNull(tc.getTag());
});
final ExtensionMetadataContainer allExtensions = extensionClient.findExtensions((ExtensionFilterParams)null);
final ExtensionMetadataContainer allExtensions = extensionClient.findExtensions((ExtensionFilterParams) null);
assertNotNull(allExtensions);
assertNotNull(allExtensions.getExtensions());
assertEquals(4, allExtensions.getNumResults());
@ -871,7 +867,7 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
context1.setName("Parameter Context 1");
context1.setParameters(new HashSet<>(Arrays.asList(param1, param2)));
final Map<String,VersionedParameterContext> contexts = new HashMap<>();
final Map<String, VersionedParameterContext> contexts = new HashMap<>();
contexts.put(context1.getName(), context1);
// Create an external controller service reference
@ -888,7 +884,7 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
final Map<String, ParameterProviderReference> parameterProviderReferences = new HashMap<>();
parameterProviderReferences.put(parameterProviderReference.getIdentifier(), parameterProviderReference);
final Map<String,ExternalControllerServiceReference> serviceReferences = new HashMap<>();
final Map<String, ExternalControllerServiceReference> serviceReferences = new HashMap<>();
serviceReferences.put(serviceReference.getIdentifier(), serviceReference);
// Create the snapshot
@ -1019,7 +1015,7 @@ public class UnsecuredNiFiRegistryClientIT extends UnsecuredITBase {
subProcessGroup.setName("Sub Process Group");
rootProcessGroup.getProcessGroups().add(subProcessGroup);
final Map<String,String> processorProperties = new HashMap<>();
final Map<String, String> processorProperties = new HashMap<>();
processorProperties.put("Prop 1", "Val 1");
processorProperties.put("Prop 2", "Val 2");

74
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/link/TestLinkService.java
View File

@ -16,13 +16,13 @@
*/
package org.apache.nifi.registry.web.link;
import org.apache.nifi.extension.ExtensionMetadata;
import org.apache.nifi.registry.bucket.Bucket;
import org.apache.nifi.registry.bucket.BucketItem;
import org.apache.nifi.registry.bucket.BucketItemType;
import org.apache.nifi.registry.extension.bundle.Bundle;
import org.apache.nifi.registry.extension.bundle.BundleInfo;
import org.apache.nifi.registry.extension.bundle.BundleVersionMetadata;
import org.apache.nifi.extension.ExtensionMetadata;
import org.apache.nifi.registry.extension.repo.ExtensionRepoArtifact;
import org.apache.nifi.registry.extension.repo.ExtensionRepoBucket;
import org.apache.nifi.registry.extension.repo.ExtensionRepoExtensionMetadata;
@ -30,15 +30,17 @@ import org.apache.nifi.registry.extension.repo.ExtensionRepoGroup;
import org.apache.nifi.registry.extension.repo.ExtensionRepoVersionSummary;
import org.apache.nifi.registry.flow.VersionedFlow;
import org.apache.nifi.registry.flow.VersionedFlowSnapshotMetadata;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import javax.ws.rs.core.UriBuilder;
import java.net.URI;
import java.util.ArrayList;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
public class TestLinkService {
private static final String BASE_URI = "http://localhost:18080/nifi-registry-api";
@ -61,7 +63,7 @@ public class TestLinkService {
private List<ExtensionRepoVersionSummary> extensionRepoVersions;
private List<ExtensionRepoExtensionMetadata> extensionRepoExtensionMetadata;
@Before
@BeforeEach
public void setup() {
linkService = new LinkService();
@ -224,60 +226,60 @@ public class TestLinkService {
@Test
public void testPopulateBucketLinks() {
buckets.forEach(b -> Assert.assertNull(b.getLink()));
buckets.forEach(b -> assertNull(b.getLink()));
linkService.populateLinks(buckets);
buckets.forEach(b -> Assert.assertEquals(
buckets.forEach(b -> assertEquals(
"buckets/" + b.getIdentifier(), b.getLink().getUri().toString()));
}
@Test
public void testPopulateFlowLinks() {
flows.forEach(f -> Assert.assertNull(f.getLink()));
flows.forEach(f -> assertNull(f.getLink()));
linkService.populateLinks(flows);
flows.forEach(f -> Assert.assertEquals(
flows.forEach(f -> assertEquals(
"buckets/" + f.getBucketIdentifier() + "/flows/" + f.getIdentifier(), f.getLink().getUri().toString()));
}
@Test
public void testPopulateSnapshotLinks() {
snapshots.forEach(s -> Assert.assertNull(s.getLink()));
snapshots.forEach(s -> assertNull(s.getLink()));
linkService.populateLinks(snapshots);
snapshots.forEach(s -> Assert.assertEquals(
snapshots.forEach(s -> assertEquals(
"buckets/" + s.getBucketIdentifier() + "/flows/" + s.getFlowIdentifier() + "/versions/" + s.getVersion(), s.getLink().getUri().toString()));
}
@Test
public void testPopulateItemLinks() {
items.forEach(i -> Assert.assertNull(i.getLink()));
items.forEach(i -> assertNull(i.getLink()));
linkService.populateLinks(items);
items.forEach(i -> {
if (i.getType() == BucketItemType.Flow) {
Assert.assertEquals("buckets/" + i.getBucketIdentifier() + "/flows/" + i.getIdentifier(), i.getLink().getUri().toString());
assertEquals("buckets/" + i.getBucketIdentifier() + "/flows/" + i.getIdentifier(), i.getLink().getUri().toString());
} else {
Assert.assertEquals("bundles/" + i.getIdentifier(), i.getLink().getUri().toString());
assertEquals("bundles/" + i.getIdentifier(), i.getLink().getUri().toString());
}
});
}
@Test
public void testPopulateExtensionBundleLinks() {
bundles.forEach(i -> Assert.assertNull(i.getLink()));
bundles.forEach(i -> assertNull(i.getLink()));
linkService.populateLinks(bundles);
bundles.forEach(eb -> Assert.assertEquals("bundles/" + eb.getIdentifier(), eb.getLink().getUri().toString()));
bundles.forEach(eb -> assertEquals("bundles/" + eb.getIdentifier(), eb.getLink().getUri().toString()));
}
@Test
public void testPopulateExtensionBundleVersionLinks() {
bundleVersionMetadata.forEach(i -> Assert.assertNull(i.getLink()));
bundleVersionMetadata.forEach(i -> assertNull(i.getLink()));
linkService.populateLinks(bundleVersionMetadata);
bundleVersionMetadata.forEach(eb -> Assert.assertEquals(
bundleVersionMetadata.forEach(eb -> assertEquals(
"bundles/" + eb.getBundleId() + "/versions/" + eb.getVersion(), eb.getLink().getUri().toString()));
}
@Test
public void testPopulateExtensionBundleVersionExtensionMetadataLinks() {
extensionMetadata.forEach(i -> Assert.assertNull(i.getLink()));
extensionMetadata.forEach(i -> Assert.assertNull(i.getLinkDocs()));
extensionMetadata.forEach(i -> assertNull(i.getLink()));
extensionMetadata.forEach(i -> assertNull(i.getLinkDocs()));
linkService.populateLinks(extensionMetadata);
@ -285,16 +287,16 @@ public class TestLinkService {
final String extensionUri = "bundles/" + e.getBundleInfo().getBundleId()
+ "/versions/" + e.getBundleInfo().getVersion()
+ "/extensions/" + e.getName();
Assert.assertEquals(extensionUri, e.getLink().getUri().toString());
Assert.assertEquals(extensionUri + "/docs", e.getLinkDocs().getUri().toString());
assertEquals(extensionUri, e.getLink().getUri().toString());
assertEquals(extensionUri + "/docs", e.getLinkDocs().getUri().toString());
});
}
@Test
public void testPopulateExtensionRepoBucketLinks() {
extensionRepoBuckets.forEach(i -> Assert.assertNull(i.getLink()));
extensionRepoBuckets.forEach(i -> assertNull(i.getLink()));
linkService.populateLinks(extensionRepoBuckets);
extensionRepoBuckets.forEach(i -> Assert.assertEquals(
extensionRepoBuckets.forEach(i -> assertEquals(
"extension-repository/" + i.getBucketName(),
i.getLink().getUri().toString())
);
@ -302,10 +304,10 @@ public class TestLinkService {
@Test
public void testPopulateExtensionRepoGroupLinks() {
extensionRepoGroups.forEach(i -> Assert.assertNull(i.getLink()));
extensionRepoGroups.forEach(i -> assertNull(i.getLink()));
linkService.populateLinks(extensionRepoGroups);
extensionRepoGroups.forEach(i -> {
Assert.assertEquals(
assertEquals(
"extension-repository/" + i.getBucketName() + "/" + i.getGroupId(),
i.getLink().getUri().toString()); }
);
@ -313,10 +315,10 @@ public class TestLinkService {
@Test
public void testPopulateExtensionRepoArtifactLinks() {
extensionRepoArtifacts.forEach(i -> Assert.assertNull(i.getLink()));
extensionRepoArtifacts.forEach(i -> assertNull(i.getLink()));
linkService.populateLinks(extensionRepoArtifacts);
extensionRepoArtifacts.forEach(i -> {
Assert.assertEquals(
assertEquals(
"extension-repository/" + i.getBucketName() + "/" + i.getGroupId() + "/" + i.getArtifactId(),
i.getLink().getUri().toString()); }
);
@ -324,10 +326,10 @@ public class TestLinkService {
@Test
public void testPopulateExtensionRepoVersionLinks() {
extensionRepoVersions.forEach(i -> Assert.assertNull(i.getLink()));
extensionRepoVersions.forEach(i -> assertNull(i.getLink()));
linkService.populateLinks(extensionRepoVersions);
extensionRepoVersions.forEach(i -> {
Assert.assertEquals(
assertEquals(
"extension-repository/" + i.getBucketName() + "/" + i.getGroupId() + "/" + i.getArtifactId() + "/" + i.getVersion(),
i.getLink().getUri().toString()); }
);
@ -335,10 +337,10 @@ public class TestLinkService {
@Test
public void testPopulateExtensionRepoVersionFullLinks() {
extensionRepoVersions.forEach(i -> Assert.assertNull(i.getLink()));
extensionRepoVersions.forEach(i -> assertNull(i.getLink()));
linkService.populateFullLinks(extensionRepoVersions, baseUri);
extensionRepoVersions.forEach(i -> {
Assert.assertEquals(
assertEquals(
BASE_URI + "/extension-repository/" + i.getBucketName() + "/" + i.getGroupId() + "/" + i.getArtifactId() + "/" + i.getVersion(),
i.getLink().getUri().toString()); }
);
@ -346,16 +348,16 @@ public class TestLinkService {
@Test
public void testPopulateExtensionRepoExtensionMetdataFullLinks() {
extensionRepoExtensionMetadata.forEach(i -> Assert.assertNull(i.getLink()));
extensionRepoExtensionMetadata.forEach(i -> Assert.assertNull(i.getLinkDocs()));
extensionRepoExtensionMetadata.forEach(i -> assertNull(i.getLink()));
extensionRepoExtensionMetadata.forEach(i -> assertNull(i.getLinkDocs()));
linkService.populateFullLinks(extensionRepoExtensionMetadata, baseUri);
extensionRepoExtensionMetadata.forEach(i -> {
final BundleInfo bi = i.getExtensionMetadata().getBundleInfo();
final String extensionUri = BASE_URI + "/extension-repository/" + bi.getBucketName() + "/" + bi.getGroupId() + "/"
+ bi.getArtifactId() + "/" + bi.getVersion() + "/extensions/" + i.getExtensionMetadata().getName();
Assert.assertEquals(extensionUri, i.getLink().getUri().toString());
Assert.assertEquals(extensionUri + "/docs", i.getLinkDocs().getUri().toString());
assertEquals(extensionUri, i.getLink().getUri().toString());
assertEquals(extensionUri + "/docs", i.getLinkDocs().getUri().toString());
});
}
}

35
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/security/authentication/oidc/OidcServiceTest.java
View File

@ -19,16 +19,17 @@ package org.apache.nifi.registry.web.security.authentication.oidc;
import com.nimbusds.oauth2.sdk.AuthorizationCode;
import com.nimbusds.oauth2.sdk.AuthorizationCodeGrant;
import com.nimbusds.oauth2.sdk.id.State;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.net.URI;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ -38,23 +39,23 @@ public class OidcServiceTest {
public static final String TEST_REQUEST_IDENTIFIER = "test-request-identifier";
public static final String TEST_STATE = "test-state";
@Test(expected = IllegalStateException.class)
@Test
public void testOidcNotEnabledCreateState() throws Exception {
final OidcService service = getServiceWithNoOidcSupport();
service.createState(TEST_REQUEST_IDENTIFIER);
assertThrows(IllegalStateException.class, () -> service.createState(TEST_REQUEST_IDENTIFIER));
}
@Test(expected = IllegalStateException.class)
@Test
public void testCreateStateMultipleInvocations() throws Exception {
final OidcService service = getServiceWithOidcSupport();
service.createState(TEST_REQUEST_IDENTIFIER);
service.createState(TEST_REQUEST_IDENTIFIER);
assertThrows(IllegalStateException.class, () -> service.createState(TEST_REQUEST_IDENTIFIER));
}
@Test(expected = IllegalStateException.class)
@Test
public void testOidcNotEnabledValidateState() throws Exception {
final OidcService service = getServiceWithNoOidcSupport();
service.isStateValid(TEST_REQUEST_IDENTIFIER, new State(TEST_STATE));
assertThrows(IllegalStateException.class, () -> service.isStateValid(TEST_REQUEST_IDENTIFIER, new State(TEST_STATE)));
}
@Test
@ -80,23 +81,23 @@ public class OidcServiceTest {
assertFalse(service.isStateValid(TEST_REQUEST_IDENTIFIER, state));
}
@Test(expected = IllegalStateException.class)
@Test
public void testOidcNotEnabledExchangeCode() throws Exception {
final OidcService service = getServiceWithNoOidcSupport();
service.exchangeAuthorizationCodeForLoginAuthenticationToken(TEST_REQUEST_IDENTIFIER, getAuthorizationCodeGrant());
assertThrows(IllegalStateException.class, () -> service.exchangeAuthorizationCodeForLoginAuthenticationToken(TEST_REQUEST_IDENTIFIER, getAuthorizationCodeGrant()));
}
@Test(expected = IllegalStateException.class)
@Test
public void testExchangeCodeMultipleInvocation() throws Exception {
final OidcService service = getServiceWithOidcSupport();
service.exchangeAuthorizationCodeForLoginAuthenticationToken(TEST_REQUEST_IDENTIFIER, getAuthorizationCodeGrant());
service.exchangeAuthorizationCodeForLoginAuthenticationToken(TEST_REQUEST_IDENTIFIER, getAuthorizationCodeGrant());
assertThrows(IllegalStateException.class, () -> service.exchangeAuthorizationCodeForLoginAuthenticationToken(TEST_REQUEST_IDENTIFIER, getAuthorizationCodeGrant()));
}
@Test(expected = IllegalStateException.class)
@Test
public void testOidcNotEnabledGetJwt() throws Exception {
final OidcService service = getServiceWithNoOidcSupport();
service.getJwt(TEST_REQUEST_IDENTIFIER);
assertThrows(IllegalStateException.class, () -> service.getJwt(TEST_REQUEST_IDENTIFIER));
}
@Test

6
nifi-registry/nifi-registry-core/nifi-registry-web-api/src/test/java/org/apache/nifi/registry/web/security/authentication/oidc/StandardOidcIdentityProviderTest.java
View File

@ -19,14 +19,14 @@ package org.apache.nifi.registry.web.security.authentication.oidc;
import com.nimbusds.oauth2.sdk.Scope;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.apache.nifi.registry.properties.NiFiRegistryProperties;
import org.junit.Test;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

14
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITCreateBucket.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
@ -34,8 +34,8 @@ import io.github.bonigarcia.wdm.WebDriverManager;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class ITCreateBucket {
private WebDriver driver;
@ -44,7 +44,7 @@ public class ITCreateBucket {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -95,7 +95,7 @@ public class ITCreateBucket {
assertEquals(1, bucketCount.size());
}
@After
@AfterEach
public void tearDown() throws Exception {
// bucket cleanup

12
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITCreateBucketCancel.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.NoAlertPresentException;
@ -31,7 +31,7 @@ import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import io.github.bonigarcia.wdm.WebDriverManager;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.fail;
public class ITCreateBucketCancel {
private WebDriver driver;
@ -40,7 +40,7 @@ public class ITCreateBucketCancel {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -91,7 +91,7 @@ public class ITCreateBucketCancel {
}
@After
@AfterEach
public void tearDown() throws Exception {
driver.quit();
String verificationErrorString = verificationErrors.toString();

14
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITCreateDuplicateBucket.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
@ -35,8 +35,8 @@ import io.github.bonigarcia.wdm.WebDriverManager;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class ITCreateDuplicateBucket {
private WebDriver driver;
@ -45,7 +45,7 @@ public class ITCreateDuplicateBucket {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -141,7 +141,7 @@ public class ITCreateDuplicateBucket {
assertEquals(1, bucketCount.size());
}
@After
@AfterEach
public void tearDown() throws Exception {
// bucket cleanup

14
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITCreateMultipleBuckets.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
@ -34,8 +34,8 @@ import io.github.bonigarcia.wdm.WebDriverManager;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class ITCreateMultipleBuckets {
private WebDriver driver;
@ -44,7 +44,7 @@ public class ITCreateMultipleBuckets {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -127,7 +127,7 @@ public class ITCreateMultipleBuckets {
}
@After
@AfterEach
public void tearDown() throws Exception {
// bucket cleanup

14
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITDeleteSingleBucket.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.NoAlertPresentException;
@ -33,8 +33,8 @@ import io.github.bonigarcia.wdm.WebDriverManager;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class ITDeleteSingleBucket {
private WebDriver driver;
@ -43,7 +43,7 @@ public class ITDeleteSingleBucket {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -117,7 +117,7 @@ public class ITDeleteSingleBucket {
wait.until(ExpectedConditions.visibilityOfElementLocated(By.cssSelector("[data-automation-id='no-buckets-message']")));
}
@After
@AfterEach
public void tearDown() throws Exception {
driver.quit();
String verificationErrorString = verificationErrors.toString();

14
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITDeleteSingleBucketCancel.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
@ -34,8 +34,8 @@ import io.github.bonigarcia.wdm.WebDriverManager;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class ITDeleteSingleBucketCancel {
private WebDriver driver;
@ -44,7 +44,7 @@ public class ITDeleteSingleBucketCancel {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -116,7 +116,7 @@ public class ITDeleteSingleBucketCancel {
assertEquals(1, bucketCount.size());
}
@After
@AfterEach
public void tearDown() throws Exception {
// bucket cleanup

14
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITRenameBucket.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
@ -35,8 +35,8 @@ import io.github.bonigarcia.wdm.WebDriverManager;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class ITRenameBucket {
private WebDriver driver;
@ -45,7 +45,7 @@ public class ITRenameBucket {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -132,7 +132,7 @@ public class ITRenameBucket {
assertEquals(1, bucketCount.size());
}
@After
@AfterEach
public void tearDown() throws Exception {
// wait for side nav to close
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.className("mat-sidenav")));

14
nifi-registry/nifi-registry-core/nifi-registry-web-ui/src/test/java/org/apache/nifi/registry/ui/ITRenameBucketDuplicate.java
View File

@ -17,9 +17,9 @@
package org.apache.nifi.registry.ui;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.JavascriptExecutor;
@ -35,8 +35,8 @@ import io.github.bonigarcia.wdm.WebDriverManager;
import java.util.List;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.fail;
public class ITRenameBucketDuplicate {
private WebDriver driver;
@ -45,7 +45,7 @@ public class ITRenameBucketDuplicate {
private WebDriverWait wait;
private StringBuffer verificationErrors = new StringBuffer();
@Before
@BeforeEach
public void setUp() throws Exception {
WebDriverManager.chromedriver().setup();
driver = new ChromeDriver();
@ -180,7 +180,7 @@ public class ITRenameBucketDuplicate {
assertEquals(2, bucketCount.size());
}
@After
@AfterEach
public void tearDown() throws Exception {
// wait for side nav to close
wait.until(ExpectedConditions.invisibilityOfElementLocated(By.className("mat-sidenav")));