Fix BLOCKER BUGs reported by Sonar

Signed-off-by: Vasyl Razinkov <vasyl.razinkov@est.tech>
Change-Id: I00c466ac3fcbe8fab4629aed3a36bb2d8af3a970
Issue-ID: SDC-3472

15 files changed, 628 insertions, 609 deletions

diff --git a/asdctool/src/test/java/org/openecomp/sdc/asdctool/impl/validator/tasks/artifacts/ArtifactValidationUtilsTest.java b/asdctool/src/test/java/org/openecomp/sdc/asdctool/impl/validator/tasks/artifacts/ArtifactValidationUtilsTest.java
index 26ad7d8e20..58ce1979f2 100644
--- a/asdctool/src/test/java/org/openecomp/sdc/asdctool/impl/validator/tasks/artifacts/ArtifactValidationUtilsTest.java
+++ b/asdctool/src/test/java/org/openecomp/sdc/asdctool/impl/validator/tasks/artifacts/ArtifactValidationUtilsTest.java
@@ -38,6 +38,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.stream.IntStream;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
@@ -55,13 +56,21 @@ import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus;
 
 public class ArtifactValidationUtilsTest {
 
+    private static final String ES_ID = "testEsInCassandra";
+    private static final String ES_ID_NOT_IN_CASS = "testEsNotInCassandra";
+    private static final String TASK_NAME = "testTaskName";
+    private static final String UNIQUE_ID = "4321";
+    private static final String UNIQUE_ID_VERTEX = "321";
+    private static final String resourcePath = new File("src/test/resources").getAbsolutePath();
+    private static final String txtReportFilePath = ValidationConfigManager.txtReportFilePath(resourcePath);
+
+    @InjectMocks
+    private ArtifactValidationUtils testSubject;
+
     @Mock
     private ArtifactCassandraDao artifactCassandraDao;
     @Mock
     private TopologyTemplateOperation topologyTemplateOperation;
-    @InjectMocks
-    private ArtifactValidationUtils testSubject;
-
     @Mock
     private GraphVertex vertex;
     @Mock
@@ -75,20 +84,11 @@ public class ArtifactValidationUtilsTest {
     @Mock
     private TopologyTemplate topologyTemplate;
 
-    private static final String ES_ID = "testEsInCassandra";
-    private static final String ES_ID_NOT_IN_CASS = "testEsNotInCassandra";
-    private static final String TASK_NAME = "testTaskName";
-    private static final String UNIQUE_ID = "4321";
-    private static final String UNIQUE_ID_VERTEX = "321";
-
-    private final static String resourcePath = new File("src/test/resources").getAbsolutePath();
-    private final static String txtReportFilePath = ValidationConfigManager.txtReportFilePath(resourcePath);
-
-    ArtifactValidationUtilsTest () {
+    @BeforeEach
+    public void initMocks() {
         MockitoAnnotations.initMocks(this);
         when(artifactCassandraDao.getCountOfArtifactById(ES_ID)).thenReturn(Either.left(1L));
-        when(artifactCassandraDao.getCountOfArtifactById(ES_ID_NOT_IN_CASS))
-            .thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND));
+        when(artifactCassandraDao.getCountOfArtifactById(ES_ID_NOT_IN_CASS)).thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND));
 
         when(artifactDataDefinition.getEsId()).thenReturn(ES_ID);
         when(artifactDataDefinitionNotInCassandra.getEsId()).thenReturn(ES_ID_NOT_IN_CASS);
diff --git a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/core/SdcMigrationToolTest.java b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/core/SdcMigrationToolTest.java
index a9172a331b..882e685ebe 100644
--- a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/core/SdcMigrationToolTest.java
+++ b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/core/SdcMigrationToolTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,103 +20,98 @@
 
 package org.openecomp.sdc.asdctool.migration.core;
 
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Arrays;
+import java.util.Collections;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
 import org.mockito.internal.verification.Times;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.asdctool.migration.core.task.Migration;
 import org.openecomp.sdc.asdctool.migration.core.task.MigrationResult;
 import org.openecomp.sdc.asdctool.migration.resolver.MigrationResolver;
 import org.openecomp.sdc.asdctool.migration.service.SdcRepoService;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
-
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
 
-public class SdcMigrationToolTest {
-
-	@InjectMocks
-	private SdcMigrationTool testInstance = spy(SdcMigrationTool.class);
-
-	@Mock
-	private MigrationResolver migrationResolverMock;
-
-	@Mock
-	private SdcRepoService sdcRepoServiceMock;
-
-	@BeforeMethod
-    public void setUp() {
-		MockitoAnnotations.initMocks(this);
-	}
-
-	@Test
-    public void testMigrate_noMigrations() {
-		when(migrationResolverMock.resolveMigrations()).thenReturn(Collections.emptyList());
-		testInstance.migrate(false);
-		verify(sdcRepoServiceMock, new Times(0)).clearTasksForCurrentMajor();
-		verify(sdcRepoServiceMock, new Times(0)).createMigrationTask(Mockito.any());
-	}
-
-	@Test
-    public void testMigrate_enforceFlag_removeAllMigrationTasksForCurrentVersion() {
-		when(migrationResolverMock.resolveMigrations()).thenReturn(Collections.emptyList());
-		testInstance.migrate(true);
-		verify(sdcRepoServiceMock, new Times(1)).clearTasksForCurrentMajor();
-	}
-
-	@Test
-    public void testMigrate_stopAfterFirstFailure() {
-		when(migrationResolverMock.resolveMigrations())
-				.thenReturn(Arrays.asList(new SuccessfulMigration(), new FailedMigration(), new SuccessfulMigration()));
-		testInstance.migrate(false);
-		verify(sdcRepoServiceMock, new Times(0)).clearTasksForCurrentMajor();
-		verify(sdcRepoServiceMock, new Times(1)).createMigrationTask(Mockito.any());
-
-	}
-
-	private class FailedMigration implements Migration {
-
-		@Override
-		public String description() {
-			return null;
-		}
-
-		@Override
-		public DBVersion getVersion() {
-			return DBVersion.fromString("1710.22");
-		}
-
-		@Override
-		public MigrationResult migrate() {
-			MigrationResult migrationResult = new MigrationResult();
-			migrationResult.setMigrationStatus(MigrationResult.MigrationStatus.FAILED);
-			return migrationResult;
-		}
-	}
-
-	private class SuccessfulMigration implements Migration {
-
-		@Override
-		public String description() {
-			return null;
-		}
-
-		@Override
-		public DBVersion getVersion() {
-			return DBVersion.fromString("1710.22");
-		}
-
-		@Override
-		public MigrationResult migrate() {
-			MigrationResult migrationResult = new MigrationResult();
-			migrationResult.setMigrationStatus(MigrationResult.MigrationStatus.COMPLETED);
-			return migrationResult;
-		}
-	}
+@ExtendWith(MockitoExtension.class)
+class SdcMigrationToolTest {
+
+    @InjectMocks
+    private SdcMigrationTool testInstance = spy(SdcMigrationTool.class);
+
+    @Mock
+    private MigrationResolver migrationResolverMock;
+
+    @Mock
+    private SdcRepoService sdcRepoServiceMock;
+
+    @Test
+    void testMigrate_noMigrations() {
+        when(migrationResolverMock.resolveMigrations()).thenReturn(Collections.emptyList());
+        testInstance.migrate(false);
+        verify(sdcRepoServiceMock, new Times(0)).clearTasksForCurrentMajor();
+        verify(sdcRepoServiceMock, new Times(0)).createMigrationTask(Mockito.any());
+    }
+
+    @Test
+    void testMigrate_enforceFlag_removeAllMigrationTasksForCurrentVersion() {
+        when(migrationResolverMock.resolveMigrations()).thenReturn(Collections.emptyList());
+        testInstance.migrate(true);
+        verify(sdcRepoServiceMock, new Times(1)).clearTasksForCurrentMajor();
+    }
+
+    @Test
+    void testMigrate_stopAfterFirstFailure() {
+        when(migrationResolverMock.resolveMigrations())
+            .thenReturn(Arrays.asList(new SuccessfulMigration(), new FailedMigration(), new SuccessfulMigration()));
+        testInstance.migrate(false);
+        verify(sdcRepoServiceMock, new Times(0)).clearTasksForCurrentMajor();
+        verify(sdcRepoServiceMock, new Times(1)).createMigrationTask(Mockito.any());
+
+    }
+
+    private class FailedMigration implements Migration {
+
+        @Override
+        public String description() {
+            return null;
+        }
+
+        @Override
+        public DBVersion getVersion() {
+            return DBVersion.fromString("1710.22");
+        }
+
+        @Override
+        public MigrationResult migrate() {
+            MigrationResult migrationResult = new MigrationResult();
+            migrationResult.setMigrationStatus(MigrationResult.MigrationStatus.FAILED);
+            return migrationResult;
+        }
+    }
+
+    private class SuccessfulMigration implements Migration {
+
+        @Override
+        public String description() {
+            return null;
+        }
+
+        @Override
+        public DBVersion getVersion() {
+            return DBVersion.fromString("1710.22");
+        }
+
+        @Override
+        public MigrationResult migrate() {
+            MigrationResult migrationResult = new MigrationResult();
+            migrationResult.setMigrationStatus(MigrationResult.MigrationStatus.COMPLETED);
+            return migrationResult;
+        }
+    }
 }
diff --git a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/resolver/SpringBeansMigrationResolverTest.java b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/resolver/SpringBeansMigrationResolverTest.java
index ffccc4d9c2..a169e6f752 100644
--- a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/resolver/SpringBeansMigrationResolverTest.java
+++ b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/resolver/SpringBeansMigrationResolverTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,9 +20,20 @@
 
 package org.openecomp.sdc.asdctool.migration.resolver;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.asdctool.migration.core.DBVersion;
 import org.openecomp.sdc.asdctool.migration.core.task.IMigrationStage;
 import org.openecomp.sdc.asdctool.migration.core.task.Migration;
@@ -30,85 +41,74 @@ import org.openecomp.sdc.asdctool.migration.core.task.MigrationResult;
 import org.openecomp.sdc.asdctool.migration.dao.MigrationTasksDao;
 import org.openecomp.sdc.asdctool.migration.service.SdcRepoService;
 import org.openecomp.sdc.be.dao.cassandra.CassandraClient;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
 
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertTrue;
-
-public class SpringBeansMigrationResolverTest {
+@ExtendWith(MockitoExtension.class)
+class SpringBeansMigrationResolverTest {
 
-	@InjectMocks
-	private SpringBeansMigrationResolver testInstance;
+    @InjectMocks
+    private SpringBeansMigrationResolver testInstance;
 
-	@Mock
-	private SdcRepoService sdcRepoServiceMock;
+    @Mock
+    private SdcRepoService sdcRepoServiceMock;
 
-	private List<Migration> migrations = Arrays.asList(createMigration("1710.1"), createMigration("1710.22"),
-			createMigration("1707.12"), createMigration("1710.3"));
+    private List<Migration> migrations = Arrays.asList(createMigration("1710.1"), createMigration("1710.22"),
+        createMigration("1707.12"), createMigration("1710.3"));
 
-	@BeforeMethod
+    @BeforeEach
     public void setUp() {
-		MockitoAnnotations.initMocks(this);
-		testInstance.setMigrations(migrations);
-	}
-
-	@Test
-    public void testResolveMigrations_getMigrationsWithVersionGreaterThanLatest() {
-		when(sdcRepoServiceMock.getLatestDBVersion()).thenReturn(DBVersion.fromString("1710.2"));
-		testInstance.setPostMigrations(Collections.emptyList());
-		List<IMigrationStage> resolvedMigrations = testInstance.resolveMigrations();
-		assertEquals(resolvedMigrations.size(), 2);
-		assertEquals(resolvedMigrations.get(0).getVersion(), DBVersion.fromString("1710.3"));
-		assertEquals(resolvedMigrations.get(1).getVersion(), DBVersion.fromString("1710.22"));
-	}
-
-	@Test
-    public void testResolveMigration_noLatestVersionForCurrentMajorVersion() {
-		when(sdcRepoServiceMock.getLatestDBVersion()).thenReturn(DBVersion.fromString("1710.-1"));
-		testInstance.setPostMigrations(Collections.emptyList());
-		List<IMigrationStage> resolvedMigrations = testInstance.resolveMigrations();
-		assertEquals(resolvedMigrations.size(), 3);
-		assertEquals(resolvedMigrations.get(0).getVersion(), DBVersion.fromString("1710.1"));
-		assertEquals(resolvedMigrations.get(1).getVersion(), DBVersion.fromString("1710.3"));
-		assertEquals(resolvedMigrations.get(2).getVersion(), DBVersion.fromString("1710.22"));
-	}
-
-	@Test
-    public void testResolveMigrations_emptyMigrationsList() {
-		testInstance.setMigrations(Collections.emptyList());
-		testInstance.setPostMigrations(Collections.emptyList());
-		when(sdcRepoServiceMock.getLatestDBVersion()).thenReturn(DBVersion.fromString("1710.-1"));
-		List<IMigrationStage> resolvedMigrations = testInstance.resolveMigrations();
-		assertTrue(resolvedMigrations.isEmpty());
-	}
-
-	private Migration createMigration(String version) {
-		return new Migration() {
-			@Override
-			public String description() {
-				return null;
-			}
-
-			@Override
-			public DBVersion getVersion() {
-				return DBVersion.fromString(version);
-			}
-
-			@Override
-			public MigrationResult migrate() {
-				return null;
-			}
-		};
-	}
-
-	private SpringBeansMigrationResolver createTestSubject() {
-		return new SpringBeansMigrationResolver(null, null, new SdcRepoService(new MigrationTasksDao(mock(CassandraClient.class))));
-	}
+        testInstance.setMigrations(migrations);
+    }
+
+    @Test
+    void testResolveMigrations_getMigrationsWithVersionGreaterThanLatest() {
+        when(sdcRepoServiceMock.getLatestDBVersion()).thenReturn(DBVersion.fromString("1710.2"));
+        testInstance.setPostMigrations(Collections.emptyList());
+        List<IMigrationStage> resolvedMigrations = testInstance.resolveMigrations();
+        assertEquals(resolvedMigrations.size(), 2);
+        assertEquals(resolvedMigrations.get(0).getVersion(), DBVersion.fromString("1710.3"));
+        assertEquals(resolvedMigrations.get(1).getVersion(), DBVersion.fromString("1710.22"));
+    }
+
+    @Test
+    void testResolveMigration_noLatestVersionForCurrentMajorVersion() {
+        when(sdcRepoServiceMock.getLatestDBVersion()).thenReturn(DBVersion.fromString("1710.-1"));
+        testInstance.setPostMigrations(Collections.emptyList());
+        List<IMigrationStage> resolvedMigrations = testInstance.resolveMigrations();
+        assertEquals(resolvedMigrations.size(), 3);
+        assertEquals(resolvedMigrations.get(0).getVersion(), DBVersion.fromString("1710.1"));
+        assertEquals(resolvedMigrations.get(1).getVersion(), DBVersion.fromString("1710.3"));
+        assertEquals(resolvedMigrations.get(2).getVersion(), DBVersion.fromString("1710.22"));
+    }
+
+    @Test
+    void testResolveMigrations_emptyMigrationsList() {
+        testInstance.setMigrations(Collections.emptyList());
+        testInstance.setPostMigrations(Collections.emptyList());
+        when(sdcRepoServiceMock.getLatestDBVersion()).thenReturn(DBVersion.fromString("1710.-1"));
+        List<IMigrationStage> resolvedMigrations = testInstance.resolveMigrations();
+        assertTrue(resolvedMigrations.isEmpty());
+    }
+
+    private Migration createMigration(String version) {
+        return new Migration() {
+            @Override
+            public String description() {
+                return null;
+            }
+
+            @Override
+            public DBVersion getVersion() {
+                return DBVersion.fromString(version);
+            }
+
+            @Override
+            public MigrationResult migrate() {
+                return null;
+            }
+        };
+    }
+
+    private SpringBeansMigrationResolver createTestSubject() {
+        return new SpringBeansMigrationResolver(null, null, new SdcRepoService(new MigrationTasksDao(mock(CassandraClient.class))));
+    }
 }
diff --git a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/service/SdcRepoServiceTest.java b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/service/SdcRepoServiceTest.java
index ddcbb8bdc2..e260464669 100644
--- a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/service/SdcRepoServiceTest.java
+++ b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/service/SdcRepoServiceTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,23 +20,23 @@
 
 package org.openecomp.sdc.asdctool.migration.service;
 
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.testng.Assert.assertEquals;
+
+import java.math.BigInteger;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 import org.mockito.internal.verification.Times;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.asdctool.migration.core.DBVersion;
 import org.openecomp.sdc.asdctool.migration.dao.MigrationTasksDao;
 import org.openecomp.sdc.be.resources.data.MigrationTaskEntry;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
 
-import java.math.BigInteger;
-
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.testng.Assert.assertEquals;
-
-public class SdcRepoServiceTest {
+@ExtendWith(MockitoExtension.class)
+class SdcRepoServiceTest {
 
     @InjectMocks
     private SdcRepoService testInstance;
@@ -44,13 +44,8 @@ public class SdcRepoServiceTest {
     @Mock
     private MigrationTasksDao migrationTasksDaoMock;
 
-    @BeforeMethod
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-    }
-
     @Test
-    public void testGetLatestVersion_noMinorVersionForCurrentVersion() {
+    void testGetLatestVersion_noMinorVersionForCurrentVersion() {
         when(migrationTasksDaoMock.getLatestMajorVersion()).thenReturn(DBVersion.DEFAULT_VERSION.getMajor());
         when(migrationTasksDaoMock.getLatestMinorVersion(migrationTasksDaoMock.getLatestMajorVersion())).thenReturn(BigInteger.valueOf(0));
         DBVersion latestDBVersion = testInstance.getLatestDBVersion();
@@ -59,8 +54,8 @@ public class SdcRepoServiceTest {
     }
 
     @Test
-    public void testCreateMigrationTask() {
-        MigrationTaskEntry taskEntry =  new MigrationTaskEntry();
+    void testCreateMigrationTask() {
+        MigrationTaskEntry taskEntry = new MigrationTaskEntry();
         testInstance.createMigrationTask(taskEntry);
         verify(migrationTasksDaoMock, new Times(1)).createMigrationTask(taskEntry);
     }
diff --git a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/tasks/mig1806/ForwardPathMigrationTest.java b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/tasks/mig1806/ForwardPathMigrationTest.java
index 071a30fea2..5a1f0bf0dc 100644
--- a/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/tasks/mig1806/ForwardPathMigrationTest.java
+++ b/asdctool/src/test/java/org/openecomp/sdc/asdctool/migration/tasks/mig1806/ForwardPathMigrationTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,53 +20,58 @@
 
 package org.openecomp.sdc.asdctool.migration.tasks.mig1806;
 
+import static org.junit.Assert.assertThat;
+
+import java.math.BigInteger;
 import org.hamcrest.core.Is;
 import org.hamcrest.core.IsNull;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.asdctool.migration.core.DBVersion;
 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
 import org.openecomp.sdc.be.model.jsonjanusgraph.operations.ToscaOperationFacade;
 import org.openecomp.sdc.be.model.operations.impl.UserAdminOperation;
 
-import java.math.BigInteger;
-
-import static org.junit.Assert.assertThat;
-
-public class ForwardPathMigrationTest {
+@ExtendWith(MockitoExtension.class)
+class ForwardPathMigrationTest {
 
-    ForwardPathMigration forwardPathMigration = null;
+    private ForwardPathMigration forwardPathMigration = null;
 
     @Mock
-    JanusGraphDao janusGraphDao;
+    private JanusGraphDao janusGraphDao;
 
     @Mock
-    UserAdminOperation userAdminOperation;
+    private UserAdminOperation userAdminOperation;
 
     @Mock
-    ToscaOperationFacade toscaOperationFacade;
+    private ToscaOperationFacade toscaOperationFacade;
 
-    @Before
+    @BeforeEach
     public void setUp() throws Exception {
         forwardPathMigration = new ForwardPathMigration(janusGraphDao, userAdminOperation, toscaOperationFacade);
     }
 
     @Test
-    public void testDescription() {
-        assertThat(forwardPathMigration,IsNull.notNullValue());
+    void testDescription() {
+        assertThat(forwardPathMigration, IsNull.notNullValue());
         assertThat("remove corrupted forwarding paths ", Is.is(forwardPathMigration.description()));
     }
 
     @Test
-    public void testGetVersion() {
+    void testGetVersion() {
         DBVersion dbVersion = DBVersion.from(BigInteger.valueOf(Version.MAJOR.getValue()), BigInteger.valueOf(Version.MINOR.getValue()));
-        assertThat(dbVersion,Is.is(forwardPathMigration.getVersion()));
+        assertThat(dbVersion, Is.is(forwardPathMigration.getVersion()));
     }
 
-    @Test(expected = NullPointerException.class)
-    public void testMigrate() {
-        assertThat(forwardPathMigration,IsNull.notNullValue());
-        forwardPathMigration.migrate();
+    @Test
+    void testMigrate() {
+        assertThat(forwardPathMigration, IsNull.notNullValue());
+        Assertions.assertThrows(NullPointerException.class, () -> {
+            forwardPathMigration.migrate();
+        });
     }
 }
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/StepsTenantIsolation.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/StepsTenantIsolation.java
index da59a033a1..6e7a75f332 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/StepsTenantIsolation.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/distribution/engine/StepsTenantIsolation.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,20 +20,28 @@
 
 package org.openecomp.sdc.be.components.distribution.engine;
 
+import static java.util.Objects.isNull;
+import static org.apache.commons.lang3.StringUtils.isEmpty;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
 import com.att.aft.dme2.api.DME2Exception;
 import com.att.aft.dme2.iterator.DME2EndpointIterator;
 import com.att.nsa.apiClient.credentials.ApiCredential;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import fj.data.Either;
 import io.cucumber.java.Before;
 import io.cucumber.java.en.Given;
 import io.cucumber.java.en.Then;
 import io.cucumber.java.en.When;
-import fj.data.Either;
+import io.cucumber.junit.Cucumber;
 import org.apache.commons.lang.NotImplementedException;
 import org.apache.commons.lang.math.NumberUtils;
 import org.apache.http.HttpStatus;
 import org.junit.Assert;
+import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Mockito;
@@ -48,19 +56,14 @@ import org.openecomp.sdc.be.resources.data.auditing.AuditingActionEnum;
 import org.openecomp.sdc.common.datastructure.Wrapper;
 import org.openecomp.sdc.common.http.client.api.HttpResponse;
 
-import static java.util.Objects.isNull;
-import static org.apache.commons.lang3.StringUtils.isEmpty;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
+@RunWith(Cucumber.class)
 public class StepsTenantIsolation {
 
     // Notification Fields
     private String operationalEnvironmentId = "28122015552391";
     private String operationalEnvironmentName = "Operational Environment Name";
     private String operationalEnvironmentType;
-    private String tenantContext ;
+    private String tenantContext;
     private String workloadContext;
     private String action;
 
@@ -87,7 +90,7 @@ public class StepsTenantIsolation {
     public void beforeScenario() {
         MockitoAnnotations.initMocks(this);
         when(operationalEnvironmentDao.getByEnvironmentsStatus(EnvironmentStatusEnum.COMPLETED))
-                .thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND));
+            .thenReturn(Either.right(CassandraOperationStatus.NOT_FOUND));
         doNothing().when(envEngine).createUebTopicsForEnvironments();
         envEngine.init();
     }
@@ -100,10 +103,10 @@ public class StepsTenantIsolation {
         if (!isNull(notification.getOperationalEnvironmentType())) {
             this.operationalEnvironmentType = notification.getOperationalEnvironmentType().getEventTypenName();
         }
-        if( !isEmpty(notification.getOperationalEnvironmentId()) ){
+        if (!isEmpty(notification.getOperationalEnvironmentId())) {
             this.operationalEnvironmentId = notification.getOperationalEnvironmentId();
         }
-        if( !isNull(notification.getAction()) ){
+        if (!isNull(notification.getAction())) {
             this.action = notification.getAction().getActionName();
         }
 
@@ -112,17 +115,17 @@ public class StepsTenantIsolation {
     @Given("^Cassandra service status is (.*)$")
     public void cassandra_service_status_is(String status) throws Throwable {
         switch (status) {
-        case "UP":
-            this.cassandraUp = true;
-            break;
-        case "DOWN":
-            when(operationalEnvironmentDao.get(operationalEnvironmentId))
+            case "UP":
+                this.cassandraUp = true;
+                break;
+            case "DOWN":
+                when(operationalEnvironmentDao.get(operationalEnvironmentId))
                     .thenReturn(Either.right(CassandraOperationStatus.GENERAL_ERROR));
-            when(operationalEnvironmentDao.save(Mockito.any(OperationalEnvironmentEntry.class)))
+                when(operationalEnvironmentDao.save(Mockito.any(OperationalEnvironmentEntry.class)))
                     .thenReturn(CassandraOperationStatus.GENERAL_ERROR);
-            break;
-        default:
-            throw new NotImplementedException();
+                break;
+            default:
+                throw new NotImplementedException();
         }
     }
 
@@ -134,28 +137,28 @@ public class StepsTenantIsolation {
         Either<OperationalEnvironmentEntry, CassandraOperationStatus> eitherResult;
         final OperationalEnvironmentEntry entryMock = Mockito.mock(OperationalEnvironmentEntry.class);
         switch (status) {
-        case "FOUND_IN_PROGRESS":
-            when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.IN_PROGRESS.getName());
-            eitherResult = Either.left(entryMock);
-            break;
-        case "FOUND_COMPLETED":
-            when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.COMPLETED.getName());
-            eitherResult = Either.left(entryMock);
-            break;
-        case "FOUND_FAILED":
-            when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.FAILED.getName());
-            eitherResult = Either.left(entryMock);
-            break;
-        case "NOT_FOUND":
-            eitherResult = Either.right(CassandraOperationStatus.NOT_FOUND);
-            break;
-        default:
-            throw new NotImplementedException();
+            case "FOUND_IN_PROGRESS":
+                when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.IN_PROGRESS.getName());
+                eitherResult = Either.left(entryMock);
+                break;
+            case "FOUND_COMPLETED":
+                when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.COMPLETED.getName());
+                eitherResult = Either.left(entryMock);
+                break;
+            case "FOUND_FAILED":
+                when(entryMock.getStatus()).thenReturn(EnvironmentStatusEnum.FAILED.getName());
+                eitherResult = Either.left(entryMock);
+                break;
+            case "NOT_FOUND":
+                eitherResult = Either.right(CassandraOperationStatus.NOT_FOUND);
+                break;
+            default:
+                throw new NotImplementedException();
         }
 
         when(operationalEnvironmentDao.get(operationalEnvironmentId)).thenReturn(eitherResult);
         when(operationalEnvironmentDao.save(Mockito.any(OperationalEnvironmentEntry.class)))
-                .thenReturn(CassandraOperationStatus.OK);
+            .thenReturn(CassandraOperationStatus.OK);
     }
 
     @Given("^AAI service status is (.*) and Tenant returned is (.*) and worload returned is (.*)$")
@@ -165,9 +168,9 @@ public class StepsTenantIsolation {
         HttpResponse<String> resp = Mockito.mock(HttpResponse.class);
         when(aaiRequestHandler.getOperationalEnvById(operationalEnvironmentId)).thenReturn(resp);
         switch (aaiServiceStatus) {
-        case "UP":
-            when(resp.getStatusCode()).thenReturn(HttpStatus.SC_OK);
-            String aaiResponseTemplate =
+            case "UP":
+                when(resp.getStatusCode()).thenReturn(HttpStatus.SC_OK);
+                String aaiResponseTemplate =
                     //@formatter:off
                     "{\r\n"
                     + "     \"operational-environment-id\": \"%s\",\r\n"
@@ -178,32 +181,32 @@ public class StepsTenantIsolation {
                     + "     \"workload-context\": \"%s\"\r\n"
                     + "    }";
                     //@formatter:on
-            when(resp.getResponse()).thenReturn(String.format(aaiResponseTemplate, operationalEnvironmentId,
+                when(resp.getResponse()).thenReturn(String.format(aaiResponseTemplate, operationalEnvironmentId,
                     operationalEnvironmentName, operationalEnvironmentType, tenantContext, workloadContext));
 
-            break;
-        case "DOWN":
-            when(resp.getStatusCode()).thenReturn(HttpStatus.SC_REQUEST_TIMEOUT);
-            break;
-        default:
-            throw new NotImplementedException();
+                break;
+            case "DOWN":
+                when(resp.getStatusCode()).thenReturn(HttpStatus.SC_REQUEST_TIMEOUT);
+                break;
+            default:
+                throw new NotImplementedException();
         }
     }
 
     @Given("^AFT_DME service status is (.*)$")
     public void aft_dme_service_status_is(String aftDmeStatus) throws Throwable {
         switch (aftDmeStatus) {
-        case "UP":
-            DME2EndpointIterator mockItr = Mockito.mock(DME2EndpointIterator.class);
-            when(mockItr.hasNext()).thenReturn(false);
-            when(epIterCreator.create(Mockito.anyString())).thenReturn(mockItr);
-            break;
-        case "DOWN":
-            when(epIterCreator.create(Mockito.anyString()))
+            case "UP":
+                DME2EndpointIterator mockItr = Mockito.mock(DME2EndpointIterator.class);
+                when(mockItr.hasNext()).thenReturn(false);
+                when(epIterCreator.create(Mockito.anyString())).thenReturn(mockItr);
+                break;
+            case "DOWN":
+                when(epIterCreator.create(Mockito.anyString()))
                     .thenThrow(new DME2Exception("dummyCode", new NotImplementedException()));
-            break;
-        default:
-            throw new NotImplementedException();
+                break;
+            default:
+                throw new NotImplementedException();
         }
     }
 
@@ -213,18 +216,18 @@ public class StepsTenantIsolation {
 
         Either<ApiCredential, CambriaErrorResponse> response;
         switch (status) {
-        case "UP":
-            ApiCredential apiCredential = Mockito.mock(ApiCredential.class);
-            when(apiCredential.getApiKey()).thenReturn("MockAPIKey");
-            when(apiCredential.getApiSecret()).thenReturn("MockSecretKey");
-            response = Either.left(apiCredential);
-            break;
-        case "DOWN":
-            CambriaErrorResponse cambriaError = Mockito.mock(CambriaErrorResponse.class);
-            response = Either.right(cambriaError);
-            break;
-        default:
-            throw new NotImplementedException();
+            case "UP":
+                ApiCredential apiCredential = Mockito.mock(ApiCredential.class);
+                when(apiCredential.getApiKey()).thenReturn("MockAPIKey");
+                when(apiCredential.getApiSecret()).thenReturn("MockSecretKey");
+                response = Either.left(apiCredential);
+                break;
+            case "DOWN":
+                CambriaErrorResponse cambriaError = Mockito.mock(CambriaErrorResponse.class);
+                response = Either.right(cambriaError);
+                break;
+            default:
+                throw new NotImplementedException();
         }
         when(cambriaHandler.createUebKeys(Mockito.anyList())).thenReturn(response);
     }
@@ -243,8 +246,8 @@ public class StepsTenantIsolation {
     @Then("^handle message activates validation of eventType (.*)$")
     public void handle_message_activates_validation_of_eventType(boolean isValidated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated)))
-                .validateEnvironmentType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class),
-                        Mockito.any(IDmaapAuditNotificationData.class));
+            .validateEnvironmentType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class),
+                Mockito.any(IDmaapAuditNotificationData.class));
     }
 
     @SuppressWarnings("unchecked")
@@ -252,43 +255,43 @@ public class StepsTenantIsolation {
     public void trying_to_write_message_to_audit_log_and_table(boolean isUnsupportedTypeEventRecorded) throws Throwable {
         int count = isUnsupportedTypeEventRecorded ? 2 : 1;
         verify(componentsUtils, Mockito.atLeast(count))
-                .auditEnvironmentEngine(Mockito.any(AuditingActionEnum.class), Mockito.eq(operationalEnvironmentId),
-                        Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(operationalEnvironmentName), Mockito.eq(tenantContext));
+            .auditEnvironmentEngine(Mockito.any(AuditingActionEnum.class), Mockito.eq(operationalEnvironmentId),
+                Mockito.any(String.class), Mockito.any(String.class), Mockito.eq(operationalEnvironmentName), Mockito.eq(tenantContext));
     }
 
     @SuppressWarnings("unchecked")
     @Then("^handle message activates validation of action (.*)$")
     public void handle_message_activates_validation_of_action(boolean isValidated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated)))
-                .validateActionType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
+            .validateActionType(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
     }
 
     @SuppressWarnings("unchecked")
     @Then("^handle message activates validation of state (.*)$")
     public void handle_message_activates_validation_of_state(boolean isValidated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isValidated)))
-                .validateState(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
+            .validateState(Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
     }
 
     @SuppressWarnings("unchecked")
     @Then("^trying to save in-progress record (.*)$")
     public void trying_to_save_in_progress_record(boolean isActivated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
-                .saveEntryWithInProgressStatus(Mockito.any(Wrapper.class), Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
+            .saveEntryWithInProgressStatus(Mockito.any(Wrapper.class), Mockito.any(Wrapper.class), Mockito.any(IDmaapNotificationData.class));
     }
 
     @SuppressWarnings("unchecked")
     @Then("^trying to get environment info from A&AI API (.*)$")
     public void trying_to_get_environment_info_from_AAI_AP(boolean isActivated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
-                .retrieveOpEnvInfoFromAAI(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
+            .retrieveOpEnvInfoFromAAI(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
     }
 
     @SuppressWarnings("unchecked")
     @Then("^trying to retrieve Ueb Addresses From AftDme (.*)$")
     public void trying_to_retrieve_ueb_addresses_from_AftDme(boolean isActivated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated))).discoverUebHosts(
-                Mockito.anyString());
+            Mockito.anyString());
 
     }
 
@@ -296,13 +299,13 @@ public class StepsTenantIsolation {
     @Then("^trying to create Ueb keys (.*)$")
     public void trying_to_create_ueb_keys(boolean isActivated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
-                .createUebKeys(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
+            .createUebKeys(Mockito.any(Wrapper.class), Mockito.any(OperationalEnvironmentEntry.class));
     }
 
     @Then("^trying to create Ueb Topics (.*)$")
     public void trying_to_create_ueb_topics(boolean isActivated) throws Throwable {
         verify(envEngine, Mockito.times(getNumberOfCallsToValidate(isActivated)))
-                .createUebTopicsForEnvironment(Mockito.any(OperationalEnvironmentEntry.class));
+            .createUebTopicsForEnvironment(Mockito.any(OperationalEnvironmentEntry.class));
     }
 
     @Then("^handle message finished successfully (.*)$")
@@ -314,12 +317,12 @@ public class StepsTenantIsolation {
 
     private String buildNotification() {
         String notificationTemplate = "{ \"operationalEnvironmentId\": \"%s\",\r\n"
-                + "             \"operationalEnvironmentName\": \"%s\",\r\n"
-                + "             \"operationalEnvironmentType\": \"%s\",\r\n" + "             \"tenantContext\": \"%s\",\r\n"
-                + "             \"workloadContext\": \"%s\",\r\n" + "             \"action\": \"%s\"}";
+            + "             \"operationalEnvironmentName\": \"%s\",\r\n"
+            + "             \"operationalEnvironmentType\": \"%s\",\r\n" + "             \"tenantContext\": \"%s\",\r\n"
+            + "             \"workloadContext\": \"%s\",\r\n" + "             \"action\": \"%s\"}";
 
         return String.format(notificationTemplate, operationalEnvironmentId, operationalEnvironmentName,
-                operationalEnvironmentType, tenantContext, workloadContext, action);
+            operationalEnvironmentType, tenantContext, workloadContext, action);
     }
 
     private int getNumberOfCallsToValidate(boolean isValidated) {
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ServiceImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ServiceImportManagerTest.java
index 16cc44f764..65fae0bfbb 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ServiceImportManagerTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ServiceImportManagerTest.java
@@ -31,14 +31,16 @@
 package org.openecomp.sdc.be.components.impl;
 
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.be.model.Service;
 import org.openecomp.sdc.be.model.UploadServiceInfo;
 
+@ExtendWith(MockitoExtension.class)
+class ServiceImportManagerTest {
 
-
-public class ServiceImportManagerTest {
     @InjectMocks
     private ServiceImportManager serviceImportManager;
 
@@ -47,7 +49,7 @@ public class ServiceImportManagerTest {
     }
 
     @Test
-    public void testGetServiceImportBusinessLogic() {
+    void testGetServiceImportBusinessLogic() {
         ServiceImportManager testSubject;
         ServiceImportBusinessLogic result;
 
@@ -56,17 +58,16 @@ public class ServiceImportManagerTest {
     }
 
     @Test
-    public void testSetServiceImportBusinessLogic() {
+    void testSetServiceImportBusinessLogic() {
         ServiceImportManager testSubject;
-        ServiceImportBusinessLogic serviceImportBusinessLogic=null;
+        ServiceImportBusinessLogic serviceImportBusinessLogic = null;
 
         testSubject = createTestSubject();
         testSubject.setServiceImportBusinessLogic(serviceImportBusinessLogic);
     }
 
-
     @Test
-    public void testGetServiceBusinessLogic() {
+    void testGetServiceBusinessLogic() {
         ServiceImportManager testSubject;
         ServiceBusinessLogic result;
 
@@ -75,7 +76,7 @@ public class ServiceImportManagerTest {
     }
 
     @Test
-    public void testSetServiceBusinessLogic() {
+    void testSetServiceBusinessLogic() {
         ServiceImportManager testSubject;
         ServiceBusinessLogic serviceBusinessLogic = null;
 
@@ -84,7 +85,7 @@ public class ServiceImportManagerTest {
     }
 
     @Test
-    public void testPopulateServiceMetadata() {
+    void testPopulateServiceMetadata() {
         UploadServiceInfo serviceMetaData = null;
         Service service = null;
         if (serviceMetaData != null || service != null) {
@@ -92,4 +93,4 @@ public class ServiceImportManagerTest {
         }
     }
 
-}
\ No newline at end of file
+}
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/cucumber/runners/RunTenantIsolationTest.java b/catalog-be/src/test/java/org/openecomp/sdc/cucumber/runners/RunTenantIsolationTest.java
index 540a2affcf..84f83d9377 100644
--- a/catalog-be/src/test/java/org/openecomp/sdc/cucumber/runners/RunTenantIsolationTest.java
+++ b/catalog-be/src/test/java/org/openecomp/sdc/cucumber/runners/RunTenantIsolationTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -22,12 +22,12 @@ package org.openecomp.sdc.cucumber.runners;
 
 import io.cucumber.junit.Cucumber;
 import io.cucumber.junit.CucumberOptions;
-import org.junit.Ignore;
 import org.junit.runner.RunWith;
 import org.openecomp.sdc.be.components.BeConfDependentTest;
 
 // TODO - investigate NPE
 @RunWith(Cucumber.class)
 @CucumberOptions(features = "classpath:cucumber/tenantIsolation.feature", glue = "org.openecomp.sdc.be.components.distribution.engine")
-public class RunTenantIsolationTest  extends BeConfDependentTest {
+public class RunTenantIsolationTest extends BeConfDependentTest {
+
 }
diff --git a/common-app-logging/src/test/java/org/openecomp/sdc/common/log/elements/LoggerFactoryTest.java b/common-app-logging/src/test/java/org/openecomp/sdc/common/log/elements/LoggerFactoryTest.java
index 0de4d9c045..9a8b7ca7bb 100644
--- a/common-app-logging/src/test/java/org/openecomp/sdc/common/log/elements/LoggerFactoryTest.java
+++ b/common-app-logging/src/test/java/org/openecomp/sdc/common/log/elements/LoggerFactoryTest.java
@@ -24,16 +24,19 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.slf4j.Logger;
 
-public class LoggerFactoryTest {
+@ExtendWith(MockitoExtension.class)
+class LoggerFactoryTest {
 
     @Mock
     private Logger logger;
 
     @Test
-    public void getMdcLoggerInstantiateProperly() {
+    void getMdcLoggerInstantiateProperly() {
         assertNotNull(LoggerFactory.getMdcLogger(LoggerAudit.class, logger));
         assertNotNull(LoggerFactory.getMdcLogger(LoggerDebug.class, logger));
         assertNotNull(LoggerFactory.getMdcLogger(LoggerMetric.class, logger));
@@ -42,7 +45,7 @@ public class LoggerFactoryTest {
     }
 
     @Test
-    public void getLoggerInstantiateProperly() {
+    void getLoggerInstantiateProperly() {
         assertNotNull(LoggerFactory.getLogger(LoggerAudit.class, logger));
         assertNotNull(LoggerFactory.getLogger(LoggerDebug.class, logger));
         assertNotNull(LoggerFactory.getLogger(LoggerMetric.class, logger));
@@ -50,12 +53,12 @@ public class LoggerFactoryTest {
     }
 
     @Test
-    public void getMdcLoggerReturnsNullForSomeInvalidClasses() {
+    void getMdcLoggerReturnsNullForSomeInvalidClasses() {
         assertNull(LoggerFactory.getMdcLogger(Integer.class, logger));
     }
 
     @Test
-    public void getLoggerReturnsNullForSomeInvalidClasses() {
+    void getLoggerReturnsNullForSomeInvalidClasses() {
         assertNull(LoggerFactory.getLogger(Integer.class, logger));
     }
 
diff --git a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/PermissionsManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/PermissionsManagerImplTest.java
index e124f841e7..2755edeafd 100644
--- a/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/PermissionsManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-item-permissions-manager/src/test/java/org/openecomp/sdc/itempermissions/dao/impl/PermissionsManagerImplTest.java
@@ -16,7 +16,32 @@
 
 package org.openecomp.sdc.itempermissions.dao.impl;
 
-import org.mockito.*;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.verify;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.ITEM_ID_PROP;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_CHANGED;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_GRANTED;
+import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.PERMISSION_ITEM;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertTrue;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.session.SessionContextProviderFactory;
 import org.openecomp.sdc.itempermissions.PermissionsServices;
@@ -25,123 +50,104 @@ import org.openecomp.sdc.notification.services.NotificationPropagationManager;
 import org.openecomp.sdc.notification.services.SubscriptionService;
 import org.openecomp.sdc.versioning.AsdcItemManager;
 import org.openecomp.sdc.versioning.types.Item;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
 
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
+@ExtendWith(MockitoExtension.class)
+class PermissionsManagerImplTest {
+
+    private static final String ITEM1_ID = "1";
+    private static final String PERMISSION = "Contributor";
+    private static final String ACTION = "Change_Item_Permissions";
+    private static final String USER = "user";
+    private static final String AFFECTED_USER1 = "affected_user1";
+    private static final String AFFECTED_USER2 = "affected_user2";
+    private static final String AFFECTED_USER3 = "affected_user3";
+    private static final String tenant = "dox";
+
+    @Mock
+    private PermissionsServices permissionsServicesMock;
+    @Mock
+    private AsdcItemManager asdcItemManagerMock;
+    @Mock
+    private SubscriptionService subscriptionServiceMock;
+    @Mock
+    private NotificationPropagationManager notifierMock;
+    @Captor
+    private ArgumentCaptor<Event> eventArgumentCaptor;
+
+    @InjectMocks
+    private PermissionsManagerImpl permissionsManager;
+
+    @BeforeEach
+    public void setUp() throws Exception {
+        SessionContextProviderFactory.getInstance().createInterface().create(USER,
+            tenant);
+        MockitoAnnotations.initMocks(this);
+    }
 
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.verify;
-import static org.openecomp.sdc.itempermissions.notifications.NotificationConstants.*;
-import static org.testng.Assert.assertEquals;
-import static org.testng.Assert.assertTrue;
+    @Test
+    void testUpdateItemPermissionsWhenNotAllowed() {
+        doReturn(false).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
+        final HashSet<String> removedUsersIds = new HashSet<>();
+        final Set<String> addedUsersIds = Collections.singleton(AFFECTED_USER1);
+        Assertions.assertThrows(CoreException.class, () -> {
+            permissionsManager.updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
+        });
+    }
 
-/**
- * Created by ayalaben on 7/6/2017
- */
-public class PermissionsManagerImplTest {
-
-  private static final String ITEM1_ID = "1";
-  private static final String PERMISSION = "Contributor";
-  private static final String ACTION = "Change_Item_Permissions";
-  private static final String USER = "user";
-  private static final String AFFECTED_USER1 = "affected_user1";
-  private static final String AFFECTED_USER2 = "affected_user2";
-  private static final String AFFECTED_USER3 = "affected_user3";
-  private static final String tenant = "dox";
-
-  @Mock
-  private PermissionsServices permissionsServicesMock;
-  @Mock
-  private AsdcItemManager asdcItemManagerMock;
-  @Mock
-  private SubscriptionService subscriptionServiceMock;
-  @Mock
-  private NotificationPropagationManager notifierMock;
-  @Captor
-  private ArgumentCaptor<Event> eventArgumentCaptor;
-
-  @InjectMocks
-  private PermissionsManagerImpl permissionsManager;
-
-
-  @BeforeMethod
-  public void setUp() throws Exception {
-    SessionContextProviderFactory.getInstance().createInterface().create(USER,
-        tenant);
-    MockitoAnnotations.initMocks(this);
-  }
-
-  @Test(expectedExceptions = CoreException.class, expectedExceptionsMessageRegExp = "Permissions " +
-          "Error. The user does not have permission to perform this action.")
-  public void testUpdateItemPermissionsWhenNotAllowed() {
-    doReturn(false).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
-
-    permissionsManager
-            .updateItemPermissions(ITEM1_ID, PERMISSION, Collections.singleton(AFFECTED_USER1),
-                    new HashSet<>());
-  }
-
-  @Test
-  public void testUpdateItemPermissions() {
-    doReturn(true).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
-    Item item = new Item();
-    item.setName("Item 1 Name");
-    doReturn(item).when(asdcItemManagerMock).get(ITEM1_ID);
-
-    Set<String> addedUsersIds =
+    @Test
+    void testUpdateItemPermissions() {
+        doReturn(true).when(permissionsServicesMock).isAllowed(ITEM1_ID, USER, ACTION);
+        Item item = new Item();
+        item.setName("Item 1 Name");
+        doReturn(item).when(asdcItemManagerMock).get(ITEM1_ID);
+
+        Set<String> addedUsersIds =
             Stream.of(AFFECTED_USER1, AFFECTED_USER2).collect(Collectors.toSet());
-    Set<String> removedUsersIds = Collections.singleton(AFFECTED_USER3);
-    permissionsManager
+        Set<String> removedUsersIds = Collections.singleton(AFFECTED_USER3);
+        permissionsManager
             .updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
 
-    verify(permissionsServicesMock)
+        verify(permissionsServicesMock)
             .updateItemPermissions(ITEM1_ID, PERMISSION, addedUsersIds, removedUsersIds);
 
-    for (String addedUsersId : addedUsersIds) {
-      verifyCallsToNotificationsFramework(addedUsersId, true);
-    }
-    for (String removedUsersId : removedUsersIds) {
-      verifyCallsToNotificationsFramework(removedUsersId, false);
+        for (String addedUsersId : addedUsersIds) {
+            verifyCallsToNotificationsFramework(addedUsersId, true);
+        }
+        for (String removedUsersId : removedUsersIds) {
+            verifyCallsToNotificationsFramework(removedUsersId, false);
+        }
     }
-  }
 
-  @Test
-  public void testListUserPermittedItems(){
-    permissionsManager.listUserPermittedItems(AFFECTED_USER1,PERMISSION);
+    @Test
+    void testListUserPermittedItems() {
+        permissionsManager.listUserPermittedItems(AFFECTED_USER1, PERMISSION);
 
-    verify(permissionsServicesMock)
+        verify(permissionsServicesMock)
             .listUserPermittedItems(AFFECTED_USER1, PERMISSION);
 
-  }
-
-  private void verifyCallsToNotificationsFramework(String affectedUser, boolean permissionGranted) {
-    verifyCallToSubscriptionService(affectedUser, permissionGranted);
-    verifyDirectNotificationCallParameters(affectedUser, permissionGranted);
-  }
-
-  private void verifyDirectNotificationCallParameters(String affectedUser, boolean permissionGranted) {
-    verify(notifierMock).directNotification(eventArgumentCaptor.capture(), Matchers.eq(affectedUser));
-    Event event = eventArgumentCaptor.getValue();
-    assertTrue(event.getEventType().equals(PERMISSION_CHANGED));
-    Map<String, Object> attributes = event.getAttributes();
-    assertEquals(attributes.get(PERMISSION_GRANTED), permissionGranted);
-    assertEquals(attributes.get(ITEM_ID_PROP), ITEM1_ID);
-    assertEquals(attributes.get(PERMISSION_ITEM), PERMISSION);
-  }
-
-  private void verifyCallToSubscriptionService(String affectedUser, boolean permissionGranted) {
-    if (permissionGranted) {
-      verify(subscriptionServiceMock).subscribe(affectedUser, ITEM1_ID);
-    } else {
-      verify(subscriptionServiceMock).unsubscribe(affectedUser, ITEM1_ID);
     }
-  }
 
+    private void verifyCallsToNotificationsFramework(String affectedUser, boolean permissionGranted) {
+        verifyCallToSubscriptionService(affectedUser, permissionGranted);
+        verifyDirectNotificationCallParameters(affectedUser, permissionGranted);
+    }
+
+    private void verifyDirectNotificationCallParameters(String affectedUser, boolean permissionGranted) {
+        verify(notifierMock).directNotification(eventArgumentCaptor.capture(), Matchers.eq(affectedUser));
+        Event event = eventArgumentCaptor.getValue();
+        assertTrue(event.getEventType().equals(PERMISSION_CHANGED));
+        Map<String, Object> attributes = event.getAttributes();
+        assertEquals(attributes.get(PERMISSION_GRANTED), permissionGranted);
+        assertEquals(attributes.get(ITEM_ID_PROP), ITEM1_ID);
+        assertEquals(attributes.get(PERMISSION_ITEM), PERMISSION);
+    }
+
+    private void verifyCallToSubscriptionService(String affectedUser, boolean permissionGranted) {
+        if (permissionGranted) {
+            verify(subscriptionServiceMock).subscribe(affectedUser, ITEM1_ID);
+        } else {
+            verify(subscriptionServiceMock).unsubscribe(affectedUser, ITEM1_ID);
+        }
+    }
 
 }
diff --git a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java
index 6a310e04c5..ef82828a1a 100644
--- a/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java
+++ b/openecomp-be/backend/openecomp-sdc-vendor-software-product-manager/src/test/java/org/openecomp/sdc/vendorsoftwareproduct/impl/ManualVspToscaManagerImplTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,53 +20,56 @@
 
 package org.openecomp.sdc.vendorsoftwareproduct.impl;
 
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.vendorsoftwareproduct.ManualVspToscaManager;
 import org.openecomp.sdc.vendorsoftwareproduct.services.ManualVspDataCollectionService;
 
+@ExtendWith(MockitoExtension.class)
 public class ManualVspToscaManagerImplTest {
 
-  private static final String USER = "manualVspToscaTestUser";
-  private static final String INVALID_VSP_ID = "Invalid_Vsp_Id";
-  private static final String VSP_ID = "Vsp_Id_1";
-  private static final String VSP_VERSION = "1.0";
-
-  private static final String RELEASE_VENDOR = "Vendor-1";
-  private static final String COMPONENT_ID = "Component_id";
-  private static final String COMPONENT_NAME = "Component_name";
-  private static final String SP_PART_NUMBER_1 = "Part_number_123";
-  private static final String FEATURE_GROUP_ID_1 = "Feature_Group_id_1";
-  private static final String MANUFACTURER_REF_1 = "Manufacturer_Ref_1";
-  private static final String VENDOR_MODEL_1 = "Deployment_Flavor_Model_1";
-  private static final int NUM_CPUS_1 = 1;
-  private static final String DISK_SIZE_1 = "2 GB";
-  private static final String MEM_SIZE_1 = "8 GB";
-
-  private static final String SP_PART_NUMBER_2 = "Part_number_345";
-  private static final String FEATURE_GROUP_ID_2 = "Feature_Group_id_2";
-  private static final String MANUFACTURER_REF_2 = "Manufacturer_Ref_2";
-  private static final String VENDOR_MODEL_2 = "Deployment_Flavor_Model_2";
-  private static final int NUM_CPUS_2 = 4;
-  private static final String DISK_SIZE_2 = "3 GB";
-  private static final String MEM_SIZE_2 = "2 GB";
-
-  private static final String IMAGE_VERSION_1 = "3.16.1";
-  private static final String IMAGE_HASH_1 = "65edfgye3256hjutve";
-  private static final String IMAGE_FILE_NAME_1 = "image-file-name1";
-  private static final String IMAGE_VERSION_2 = "3.1.9";
-  private static final String IMAGE_HASH_2 = "84rtedfe3256hjutaw";
-  private static final String IMAGE_FILE_NAME_2 = "image-file-name1";
-
-  private ManualVspToscaManager manualVspToscaManager = new ManualVspToscaManagerImpl();
-
-  @Spy
-  @InjectMocks
-  private ManualVspToscaManagerImpl manualVspToscaManagerMock;
-
-  @Mock
-  private ManualVspDataCollectionService manualVspDataCollectionServiceMock;
+    private static final String USER = "manualVspToscaTestUser";
+    private static final String INVALID_VSP_ID = "Invalid_Vsp_Id";
+    private static final String VSP_ID = "Vsp_Id_1";
+    private static final String VSP_VERSION = "1.0";
+
+    private static final String RELEASE_VENDOR = "Vendor-1";
+    private static final String COMPONENT_ID = "Component_id";
+    private static final String COMPONENT_NAME = "Component_name";
+    private static final String SP_PART_NUMBER_1 = "Part_number_123";
+    private static final String FEATURE_GROUP_ID_1 = "Feature_Group_id_1";
+    private static final String MANUFACTURER_REF_1 = "Manufacturer_Ref_1";
+    private static final String VENDOR_MODEL_1 = "Deployment_Flavor_Model_1";
+    private static final int NUM_CPUS_1 = 1;
+    private static final String DISK_SIZE_1 = "2 GB";
+    private static final String MEM_SIZE_1 = "8 GB";
+
+    private static final String SP_PART_NUMBER_2 = "Part_number_345";
+    private static final String FEATURE_GROUP_ID_2 = "Feature_Group_id_2";
+    private static final String MANUFACTURER_REF_2 = "Manufacturer_Ref_2";
+    private static final String VENDOR_MODEL_2 = "Deployment_Flavor_Model_2";
+    private static final int NUM_CPUS_2 = 4;
+    private static final String DISK_SIZE_2 = "3 GB";
+    private static final String MEM_SIZE_2 = "2 GB";
+
+    private static final String IMAGE_VERSION_1 = "3.16.1";
+    private static final String IMAGE_HASH_1 = "65edfgye3256hjutve";
+    private static final String IMAGE_FILE_NAME_1 = "image-file-name1";
+    private static final String IMAGE_VERSION_2 = "3.1.9";
+    private static final String IMAGE_HASH_2 = "84rtedfe3256hjutaw";
+    private static final String IMAGE_FILE_NAME_2 = "image-file-name1";
+
+    private ManualVspToscaManager manualVspToscaManager = new ManualVspToscaManagerImpl();
+
+    @Spy
+    @InjectMocks
+    private ManualVspToscaManagerImpl manualVspToscaManagerMock;
+
+    @Mock
+    private ManualVspDataCollectionService manualVspDataCollectionServiceMock;
   /*
 
   @Test
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-nosqldb-lib/openecomp-nosqldb-api/src/test/java/org/openecomp/core/util/UniqueValueUtilTest.java b/openecomp-be/lib/openecomp-core-lib/openecomp-nosqldb-lib/openecomp-nosqldb-api/src/test/java/org/openecomp/core/util/UniqueValueUtilTest.java
index eeae2f75b0..72ae4e7227 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-nosqldb-lib/openecomp-nosqldb-api/src/test/java/org/openecomp/core/util/UniqueValueUtilTest.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-nosqldb-lib/openecomp-nosqldb-api/src/test/java/org/openecomp/core/util/UniqueValueUtilTest.java
@@ -19,17 +19,20 @@
 
 package org.openecomp.core.util;
 
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.Mock;
 import org.mockito.Mockito;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.core.dao.UniqueValueDao;
 import org.openecomp.core.dao.types.UniqueValueEntity;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.testng.Assert;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
 
-public class UniqueValueUtilTest {
+@ExtendWith(MockitoExtension.class)
+class UniqueValueUtilTest {
 
     private static final String ENTITLEMENT_POOL_NAME = "Entitlement Pool name";
     private static final String ORIGINAL_ENTITY_NAME = "originalEntityName";
@@ -39,30 +42,31 @@ public class UniqueValueUtilTest {
 
     private UniqueValueUtil uniqueValueUtil;
 
-    @BeforeMethod
+    @BeforeEach
     public void setUp() {
-        MockitoAnnotations.initMocks(this);
         uniqueValueUtil = new UniqueValueUtil(uniqueValueDao);
     }
 
     @Test
-    public void testCreateUniqueValue() {
+    void testCreateUniqueValue() {
         Mockito.when(uniqueValueDao.get(Mockito.any())).thenReturn(null);
         uniqueValueUtil.createUniqueValue(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME);
 
         Mockito.verify(uniqueValueDao, Mockito.times(1)).create(Mockito.any());
     }
 
-    @Test(expectedExceptions = CoreException.class)
-    public void testCreateUniqueValueNotUnique() {
+    @Test
+    void testCreateUniqueValueNotUnique() {
         Mockito.when(uniqueValueDao.get(Mockito.any())).thenReturn(new UniqueValueEntity());
-        uniqueValueUtil.createUniqueValue(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME);
+        Assertions.assertThrows(CoreException.class, () -> {
+            uniqueValueUtil.createUniqueValue(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME);
+        });
 
-        Mockito.verify(uniqueValueDao, Mockito.times(1)).create(Mockito.any());
+        Mockito.verify(uniqueValueDao, Mockito.times(1)).get(Mockito.any());
     }
 
     @Test
-    public void testDeleteUniqueValue() {
+    void testDeleteUniqueValue() {
         Mockito.doNothing().when(uniqueValueDao).delete(Mockito.any());
         uniqueValueUtil.deleteUniqueValue(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME);
 
@@ -70,13 +74,13 @@ public class UniqueValueUtilTest {
     }
 
     @Test
-    public void testDeleteUniqueValueNoValue() {
+    void testDeleteUniqueValueNoValue() {
         uniqueValueUtil.deleteUniqueValue(ENTITLEMENT_POOL_NAME);
         Mockito.verify(uniqueValueDao, Mockito.times(0)).delete(Mockito.any());
     }
 
     @Test
-    public void testUpdateUniqueValue() {
+    void testUpdateUniqueValue() {
         Mockito.when(uniqueValueDao.get(Mockito.any())).thenReturn(null);
         Mockito.doNothing().when(uniqueValueDao).delete(Mockito.any());
 
@@ -87,29 +91,31 @@ public class UniqueValueUtilTest {
     }
 
     @Test
-    public void testValidateUniqueValue() {
+    void testValidateUniqueValue() {
         Mockito.when(uniqueValueDao.get(Mockito.any())).thenReturn(null);
         uniqueValueUtil.validateUniqueValue(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME);
 
         Mockito.verify(uniqueValueDao, Mockito.times(1)).get(Mockito.any());
     }
 
-    @Test(expectedExceptions = CoreException.class)
-    public void testValidateUniqueValueNotUnique() {
+    @Test
+    void testValidateUniqueValueNotUnique() {
         Mockito.when(uniqueValueDao.get(Mockito.any())).thenReturn(new UniqueValueEntity());
-        uniqueValueUtil.createUniqueValue(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME);
+        Assertions.assertThrows(CoreException.class, () -> {
+            uniqueValueUtil.createUniqueValue(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME);
+        });
 
         Mockito.verify(uniqueValueDao, Mockito.times(1)).get(Mockito.any());
     }
 
     @Test
-    public void testIsUniqueValueOccupied() {
+    void testIsUniqueValueOccupied() {
         Mockito.when(uniqueValueDao.get(Mockito.any())).thenReturn(new UniqueValueEntity());
         Assert.assertTrue(uniqueValueUtil.isUniqueValueOccupied(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME));
     }
 
     @Test
-    public void testIsUniqueValueOccupiedFalse() {
+    void testIsUniqueValueOccupiedFalse() {
         Mockito.when(uniqueValueDao.get(Mockito.any())).thenReturn(null);
         Assert.assertFalse(uniqueValueUtil.isUniqueValueOccupied(ENTITLEMENT_POOL_NAME, ORIGINAL_ENTITY_NAME));
     }
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/AsdcSessionContextProviderTest.java b/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/AsdcSessionContextProviderTest.java
index f0a9d2dcf7..80b62c7409 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/AsdcSessionContextProviderTest.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/AsdcSessionContextProviderTest.java
@@ -19,45 +19,48 @@
 
 package org.openecomp.sdc.common.session.impl;
 
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertSame;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
-import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.common.session.SessionContext;
-import org.testng.Assert;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
 
-public class AsdcSessionContextProviderTest {
+@ExtendWith(MockitoExtension.class)
+class AsdcSessionContextProviderTest {
 
     private static final String USER_ID = "cs0008";
 
     @InjectMocks
     private AsdcSessionContextProvider asdcSessionContextProvider;
 
-    @BeforeMethod
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-    }
-
-    @Test(expectedExceptions = CoreException.class)
-    public void testGetUserIdNull() {
+    @Test
+    void testGetUserIdNull() {
         asdcSessionContextProvider.create(null, null);
-        asdcSessionContextProvider.get();
+        Assertions.assertThrows(CoreException.class, () -> {
+            asdcSessionContextProvider.get();
+        });
     }
 
-    @Test(expectedExceptions = CoreException.class)
-    public void testGetTenantNull() {
+    @Test
+    void testGetTenantNull() {
         asdcSessionContextProvider.create(USER_ID, null);
-        asdcSessionContextProvider.get();
+        Assertions.assertThrows(CoreException.class, () -> {
+            asdcSessionContextProvider.get();
+        });
     }
 
     @Test
-    public void testGet() {
+    void testGet() {
         asdcSessionContextProvider.create(USER_ID, "tenant");
         SessionContext sessionContext = asdcSessionContextProvider.get();
 
-        Assert.assertNotNull(sessionContext);
-        Assert.assertSame(USER_ID, sessionContext.getUser().getUserId());
-        Assert.assertSame("tenant", sessionContext.getTenant());
+        assertNotNull(sessionContext);
+        assertSame(USER_ID, sessionContext.getUser().getUserId());
+        assertSame("tenant", sessionContext.getTenant());
     }
 }
diff --git a/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/SessionContextProviderFactoryImplTest.java b/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/SessionContextProviderFactoryImplTest.java
index eec7bd02ad..74cf8d3446 100644
--- a/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/SessionContextProviderFactoryImplTest.java
+++ b/openecomp-be/lib/openecomp-core-lib/openecomp-session-lib/src/test/java/org/openecomp/sdc/common/session/impl/SessionContextProviderFactoryImplTest.java
@@ -19,27 +19,31 @@
 
 package org.openecomp.sdc.common.session.impl;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.MockitoAnnotations;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.common.session.SessionContextProvider;
-import org.testng.Assert;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
 
-public class SessionContextProviderFactoryImplTest {
+@ExtendWith(MockitoExtension.class)
+class SessionContextProviderFactoryImplTest {
 
     @InjectMocks
     private SessionContextProviderFactoryImpl sessionContextProviderFactoryImpl;
 
-    @BeforeMethod
+    @BeforeEach
     public void setUp() {
         MockitoAnnotations.initMocks(this);
     }
 
     @Test
-    public void testCreateInterface() {
+    void testCreateInterface() {
         SessionContextProvider sessionContextProvider = sessionContextProviderFactoryImpl.createInterface();
 
-        Assert.assertTrue(sessionContextProvider instanceof AsdcSessionContextProvider);
+        assertTrue(sessionContextProvider instanceof AsdcSessionContextProvider);
     }
 }
diff --git a/openecomp-be/lib/openecomp-item-permissions-lib/openecomp-item-permissions-impl/src/test/java/org/openecomp/sdc/itempermissions/impl/PermissionsRulesImplTest.java b/openecomp-be/lib/openecomp-item-permissions-lib/openecomp-item-permissions-impl/src/test/java/org/openecomp/sdc/itempermissions/impl/PermissionsRulesImplTest.java
index a70c91c107..57339012f4 100644
--- a/openecomp-be/lib/openecomp-item-permissions-lib/openecomp-item-permissions-impl/src/test/java/org/openecomp/sdc/itempermissions/impl/PermissionsRulesImplTest.java
+++ b/openecomp-be/lib/openecomp-item-permissions-lib/openecomp-item-permissions-impl/src/test/java/org/openecomp/sdc/itempermissions/impl/PermissionsRulesImplTest.java
@@ -7,9 +7,9 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -20,102 +20,97 @@
 
 package org.openecomp.sdc.itempermissions.impl;
 
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.HashSet;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.InjectMocks;
 import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
+import org.mockito.junit.jupiter.MockitoExtension;
 import org.openecomp.sdc.common.errors.CoreException;
 import org.openecomp.sdc.itempermissions.dao.impl.PermissionsServicesImpl;
-import org.testng.Assert;
-import org.testng.annotations.BeforeMethod;
-import org.testng.annotations.Test;
-
-import java.util.HashSet;
 
+@ExtendWith(MockitoExtension.class)
+class PermissionsRulesImplTest {
+
+    private static final String ITEM1_ID = "1";
+    private static final String USER1_ID = "testUser1";
+    private static final String PERMISSION_OWNER = "Owner";
+    private static final String PERMISSION_CONTRIBUTOR = "Contributor";
+    private static final String INVALID_PERMISSION = "Invalid_Permission";
+    private static final String SUBMIT_ACTION = "Submit_Item";
+    private static final String EDIT_ACTION = "Edit_Item";
+    private static final String CHANGE_PERMISSIONS_ACTION = "Change_Item_Permissions";
+    private static final String INVALID_ACTION = "Invalid_Action";
+
+    @Mock
+    private PermissionsServicesImpl permissionsServices;
+
+    @InjectMocks
+    @Spy
+    private PermissionsRulesImpl permissionsRules;
+
+    @Test
+    void testIsAllowedWhenInvalidPermission() {
+        Assertions.assertThrows(CoreException.class, () -> {
+            permissionsRules.isAllowed(INVALID_PERMISSION, EDIT_ACTION);
+        });
+    }
 
-/**
- * Created by ayalaben on 7/10/2017
- */
-public class PermissionsRulesImplTest {
-
-  private static final String ITEM1_ID = "1";
-  private static final String USER1_ID = "testUser1";
-  private static final String PERMISSION_OWNER = "Owner";
-  private static final String PERMISSION_CONTRIBUTOR = "Contributor";
-  private static final String INVALID_PERMISSION = "Invalid_Permission";
-  private static final String SUBMIT_ACTION = "Submit_Item";
-  private static final String EDIT_ACTION = "Edit_Item";
-  private static final String CHANGE_PERMISSIONS_ACTION = "Change_Item_Permissions";
-  private static final String INVALID_ACTION = "Invalid_Action";
+    @Test
+    void testIsAllowedWhenInvalidAction() {
+        Assertions.assertThrows(CoreException.class, () -> {
+            permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR, INVALID_ACTION);
+        });
+    }
 
-  @Mock
-  private PermissionsServicesImpl permissionsServices;
+    @Test
+    void testIsAllowedCaseSubmitOwner() {
+        assertTrue(permissionsRules.isAllowed(PERMISSION_OWNER, SUBMIT_ACTION));
+    }
 
-  @InjectMocks
-  @Spy
-  private PermissionsRulesImpl permissionsRules;
+    @Test
+    void testIsAllowedCaseSubmitNotOwner() {
+        assertTrue(permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR, SUBMIT_ACTION));
+    }
 
+    @Test
+    void testIsAllowedCaseEditOwner() {
+        assertTrue(permissionsRules.isAllowed(PERMISSION_OWNER, EDIT_ACTION));
+    }
 
-  @BeforeMethod
-  public void setUp() throws Exception {
+    @Test
+    void testIsAllowedCaseEditContributer() {
+        assertTrue(permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR, EDIT_ACTION));
+    }
 
-    MockitoAnnotations.initMocks(this);
-  }
+    @Test
+    void testIsAllowedCaseChangePermissionsContributer() {
+        assertFalse(permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR, CHANGE_PERMISSIONS_ACTION));
+    }
 
-  @Test(expectedExceptions = CoreException.class,expectedExceptionsMessageRegExp =
-      "Invalid permission type")
-  public void testIsAllowedWhenInvalidPermission() {
-      permissionsRules.isAllowed(INVALID_PERMISSION, EDIT_ACTION);
+    @Test
+    void testIsAllowedCaseChangePermissionsOwner() {
+        assertTrue(permissionsRules.isAllowed(PERMISSION_OWNER, CHANGE_PERMISSIONS_ACTION));
     }
 
-  @Test(expectedExceptions = CoreException.class,expectedExceptionsMessageRegExp =
-      "Invalid action type")
-  public void testIsAllowedWhenInvalidAction() {
-    permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR, INVALID_ACTION);
-  }
-
-  @Test
-  public void testIsAllowedCaseSubmitOwner(){
-    Assert.assertTrue(permissionsRules.isAllowed(PERMISSION_OWNER,SUBMIT_ACTION));
-  }
-
-  @Test
-  public void testIsAllowedCaseSubmitNotOwner(){
-    Assert.assertTrue(permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR,SUBMIT_ACTION));
-  }
-
-  @Test
-  public void testIsAllowedCaseEditOwner(){
-    Assert.assertTrue(permissionsRules.isAllowed(PERMISSION_OWNER,EDIT_ACTION));
-  }
-
-  @Test
-  public void testIsAllowedCaseEditContributer(){
-    Assert.assertTrue(permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR,EDIT_ACTION));
-  }
-
-  @Test
-  public void testIsAllowedCaseChangePermissionsContributer(){
-    Assert.assertFalse(permissionsRules.isAllowed(PERMISSION_CONTRIBUTOR,CHANGE_PERMISSIONS_ACTION));
-  }
-
-  @Test
-  public void testIsAllowedCaseChangePermissionsOwner(){
-    Assert.assertTrue(permissionsRules.isAllowed(PERMISSION_OWNER,CHANGE_PERMISSIONS_ACTION));
-  }
-
-  @Test(expectedExceptions = CoreException.class,expectedExceptionsMessageRegExp =
-      "Invalid permission type")
-  public void testUpdatePermissionWhenInvalidPermission()  {
-    permissionsRules.updatePermission(ITEM1_ID,USER1_ID,INVALID_PERMISSION,new HashSet<String>(),
-        new HashSet<String>());
-  }
-
-  @Test(expectedExceptions = CoreException.class,expectedExceptionsMessageRegExp =
-      "Invalid action type")
-  public void testExecuteActionInvalidAction(){
-    permissionsRules.executeAction(ITEM1_ID,USER1_ID,INVALID_ACTION);
-  }
+    @Test
+    void testUpdatePermissionWhenInvalidPermission() {
+        final HashSet<String> stringHashSet = new HashSet<>();
+        Assertions.assertThrows(CoreException.class, () -> {
+            permissionsRules.updatePermission(ITEM1_ID, USER1_ID, INVALID_PERMISSION, stringHashSet, stringHashSet);
+        });
+    }
 
+    @Test
+    void testExecuteActionInvalidAction() {
+        Assertions.assertThrows(CoreException.class, () -> {
+            permissionsRules.executeAction(ITEM1_ID, USER1_ID, INVALID_ACTION);
+        });
+    }
 
 }