From 95bdca4419af09c4eeab5562589ea6baf9a4490d Mon Sep 17 00:00:00 2001 From: Neil Derraugh Date: Wed, 20 May 2020 23:59:37 -0400 Subject: Upgrade Junit to 5.6 - Update @Before -> @BeforeEach, @After -> @AfterEach - Update Mockito usage - Update assertThrows so not to expect exceptions Issue-ID: SDC-3078 Signed-off-by: Neil Derraugh Change-Id: I0b1056698767c4b060e243bbda799253072b4b55 --- pom.xml | 8 +- security-util-lib/pom.xml | 2 +- .../java/org/onap/sdc/security/SecurityUtil.java | 5 +- .../org/onap/sdc/security/utils/RestUtils.java | 4 +- .../security/AuthenticationCookieUtilsTest.java | 45 ++--- .../java/org/onap/sdc/security/CipherUtilTest.java | 49 +++-- .../java/org/onap/sdc/security/PasswordsTest.java | 34 ++-- .../onap/sdc/security/RepresentationUtilsTest.java | 19 +- .../java/org/onap/sdc/security/RestUtilsTest.java | 31 +-- .../org/onap/sdc/security/SecurityUtilTest.java | 21 +-- .../filters/RestrictionAccessFilterTest.java | 210 +++++++++++---------- .../filters/SessionValidationFilterTest.java | 111 ++++++----- .../logging/elements/LogFieldsMdcHandlerTest.java | 32 ++-- .../logging/enums/EcompLoggerErrorCodeTest.java | 16 +- .../enums/LoggerSupportabilityActionsTest.java | 25 ++- .../sdc/security/logging/enums/SeverityTest.java | 14 +- .../sdc/security/logging/enums/StatusCodeTest.java | 12 +- .../logging/wrappers/LoggerSdcAuditTest.java | 42 ++--- .../logging/wrappers/LoggerSdcUtilBaseTest.java | 29 ++- .../sdc/security/logging/wrappers/LoggerTest.java | 125 ++++++------ .../session/SdcSessionContextProviderTest.java | 25 ++- .../services/impl/VersioningManagerImpl.java | 26 ++- .../persistence/zusammen/ItemZusammenDaoTest.java | 47 +++-- .../zusammen/VersionZusammenDaoTest.java | 24 ++- .../impl/MajorVersionCalculatorImplTest.java | 20 +- .../services/impl/VersioningManagerImplTest.java | 33 ++-- .../common/zusammen/config/ZusammenConfigTest.java | 6 +- .../persistence/ZusammenConnectorTest.java | 54 +++--- .../services/impl/ZusammenAdaptorImplTest.java | 35 ++-- 29 files changed, 569 insertions(+), 535 deletions(-) diff --git a/pom.xml b/pom.xml index a4acb72..a64eab7 100644 --- a/pom.xml +++ b/pom.xml @@ -40,7 +40,7 @@ UTF-8 UTF-8 2.23.4 - 4.12 + 5.6.0 1.5.0 2.17 snapshots @@ -102,9 +102,9 @@ spring-boot-starter - junit - junit - ${junit.version} + org.junit.jupiter + junit-jupiter + ${junit.jupiter.version} test diff --git a/security-util-lib/pom.xml b/security-util-lib/pom.xml index eb8f17d..5b07389 100644 --- a/security-util-lib/pom.xml +++ b/security-util-lib/pom.xml @@ -138,7 +138,7 @@ org.apache.maven.plugins maven-surefire-plugin - 2.19.1 + 2.22.2 ${argLine} -Xmx2048m diff --git a/security-util-lib/src/main/java/org/onap/sdc/security/SecurityUtil.java b/security-util-lib/src/main/java/org/onap/sdc/security/SecurityUtil.java index eb67813..099ca0a 100644 --- a/security-util-lib/src/main/java/org/onap/sdc/security/SecurityUtil.java +++ b/security-util-lib/src/main/java/org/onap/sdc/security/SecurityUtil.java @@ -46,7 +46,6 @@ public class SecurityUtil { private static final Logger LOG = Logger.getLogger(SecurityUtil.class); - public static final SecurityUtil INSTANCE = new SecurityUtil(); public static final String ALGORITHM = "AES"; public static final String CHARSET = UTF_8.name(); @@ -69,7 +68,7 @@ public class SecurityUtil { } // obfuscates key prefix -> ********** - public String obfuscateKey(String sensitiveData) { + public static String obfuscateKey(String sensitiveData) { if (sensitiveData == null) { return null; @@ -176,7 +175,7 @@ public class SecurityUtil { return Either.right("Decrypt FAILED"); } - public Either decrypt(String byteCipherText) { + public static Either decrypt(String byteCipherText) { try { return decrypt(byteCipherText.getBytes(CHARSET), true); } catch (UnsupportedEncodingException e) { diff --git a/security-util-lib/src/main/java/org/onap/sdc/security/utils/RestUtils.java b/security-util-lib/src/main/java/org/onap/sdc/security/utils/RestUtils.java index 2803720..5df9d8a 100644 --- a/security-util-lib/src/main/java/org/onap/sdc/security/utils/RestUtils.java +++ b/security-util-lib/src/main/java/org/onap/sdc/security/utils/RestUtils.java @@ -32,6 +32,8 @@ import java.util.Properties; public class RestUtils { + private RestUtils() {} + public static void addBasicAuthHeader(Properties headers, String username, String password) { headers.setProperty(HttpHeaders.AUTHORIZATION, getAuthHeaderValue(username,password)); } @@ -49,7 +51,7 @@ public class RestUtils { @VisibleForTesting public static String decryptPassword(String password) { validate(password); - Either passkey = SecurityUtil.INSTANCE.decrypt(password); + Either passkey = SecurityUtil.decrypt(password); if(passkey.isLeft()) { return passkey.left().value(); } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/AuthenticationCookieUtilsTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/AuthenticationCookieUtilsTest.java index fdd354e..900afe2 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/AuthenticationCookieUtilsTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/AuthenticationCookieUtilsTest.java @@ -20,29 +20,32 @@ package org.onap.sdc.security; -import org.junit.Test; -import org.onap.sdc.security.filters.SampleFilter; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; -import javax.servlet.http.Cookie; import java.io.IOException; import java.util.concurrent.TimeUnit; - -import static org.junit.Assert.assertTrue; +import javax.servlet.http.Cookie; +import org.junit.jupiter.api.Test; +import org.onap.sdc.security.filters.SampleFilter; public class AuthenticationCookieUtilsTest { - private SampleFilter sessionValidationFilter = new SampleFilter(); - private ISessionValidationFilterConfiguration filterCfg = sessionValidationFilter.getFilterConfiguration(); + private final SampleFilter sessionValidationFilter = new SampleFilter(); + private final ISessionValidationFilterConfiguration filterCfg = sessionValidationFilter.getFilterConfiguration(); @Test - public void validateThatCookieCurrentSessionTimeIncreased() throws IOException, CipherUtilException, InterruptedException { + public void validateThatCookieCurrentSessionTimeIncreased() + throws IOException, CipherUtilException, InterruptedException { // original cookie, pojo and servlet cookie AuthenticationCookie authenticationCookieOriginal = new AuthenticationCookie("kuku"); - Cookie cookieWithOriginalTime = new Cookie(filterCfg.getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookieOriginal,filterCfg )); + Cookie cookieWithOriginalTime = new Cookie(filterCfg.getCookieName(), + AuthenticationCookieUtils.getEncryptedCookie(authenticationCookieOriginal, filterCfg)); // cookie with increased time, pojo and servlet cookie TimeUnit.SECONDS.sleep(1); Cookie cookieWithIncreasedTime = AuthenticationCookieUtils.updateSessionTime(cookieWithOriginalTime, filterCfg); - AuthenticationCookie authenticationCookieIncreasedTime = AuthenticationCookieUtils.getAuthenticationCookie(cookieWithIncreasedTime, filterCfg); + AuthenticationCookie authenticationCookieIncreasedTime = AuthenticationCookieUtils + .getAuthenticationCookie(cookieWithIncreasedTime, filterCfg); // validation long currentSessionTimeOriginal = authenticationCookieOriginal.getCurrentSessionTime(); long currentSessionTimeIncreased = authenticationCookieIncreasedTime.getCurrentSessionTime(); @@ -53,23 +56,11 @@ public class AuthenticationCookieUtilsTest { public void validateSerializationEncriptionDeserializationDecryption() throws IOException, CipherUtilException { // original cookie, pojo and servlet cookie AuthenticationCookie authenticationCookieOriginal = new AuthenticationCookie("kuku"); - Cookie cookieWithOriginalTime = new Cookie(filterCfg.getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookieOriginal,filterCfg )); + Cookie cookieWithOriginalTime = new Cookie(filterCfg.getCookieName(), + AuthenticationCookieUtils.getEncryptedCookie(authenticationCookieOriginal, filterCfg)); // cookie with increased time, pojo and servlet cookie - AuthenticationCookie decriptedAndDeserializedAuthenticationCookie = AuthenticationCookieUtils.getAuthenticationCookie(cookieWithOriginalTime,filterCfg); - assertTrue(authenticationCookieOriginal.equals(decriptedAndDeserializedAuthenticationCookie)); + AuthenticationCookie decriptedAndDeserializedAuthenticationCookie = AuthenticationCookieUtils + .getAuthenticationCookie(cookieWithOriginalTime, filterCfg); + assertEquals(authenticationCookieOriginal, decriptedAndDeserializedAuthenticationCookie); } - - - -// @Test -// public void getEncryptedCookie() { -// } -// -// @Test -// public void getAuthenticationCookie() { -// } -// -// @Test -// public void isSessionExpired() { -// } } \ No newline at end of file diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/CipherUtilTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/CipherUtilTest.java index 9a6646c..e8d57a1 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/CipherUtilTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/CipherUtilTest.java @@ -20,14 +20,13 @@ package org.onap.sdc.security; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + import org.apache.commons.codec.binary.Base64; import org.apache.commons.lang.RandomStringUtils; -import org.junit.Test; - -import java.util.Random; - -import static org.apache.commons.codec.binary.Base64.encodeBase64String; -import static org.junit.Assert.*; +import org.junit.jupiter.api.Test; public class CipherUtilTest { @@ -41,36 +40,34 @@ public class CipherUtilTest { String encrypted = CipherUtil.encryptPKC(DATA, base64Key); assertNotEquals(DATA, encrypted); String decrypted = CipherUtil.decryptPKC(encrypted, base64Key); - assertEquals(decrypted, DATA); + assertEquals(DATA, decrypted); } @Test public void encryptInvalidKey() { - try { - CipherUtil.encryptPKC(DATA, "invalidKey"); - fail(); - } catch (CipherUtilException ex) { - assertTrue(ex.getMessage().contains("Invalid AES key length")); - } + assertThrows( + CipherUtilException.class, + () -> CipherUtil.encryptPKC(DATA, "invalidKey"), + "Invalid AES key length" + ); } @Test public void decryptInvalidKey() { - try { - CipherUtil.decryptPKC(DATA, "invalidKey"); - fail(); - } catch (CipherUtilException ex) { - assertTrue(ex.getMessage().contains("length")); - } + assertThrows( + CipherUtilException.class, + () -> CipherUtil.decryptPKC(DATA, "invalidKey"), + "length" + + ); } @Test - public void decryptInvalidData() { - try { - CipherUtil.decryptPKC(DATA, KEY); - fail(); - } catch (CipherUtilException ex) { - assertTrue(ex.getMessage().contains("Input too short")); - } + public void decryptInvalidData() { + assertThrows( + CipherUtilException.class, + () -> CipherUtil.decryptPKC(DATA, KEY), + "Input too short" + ); } } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/PasswordsTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/PasswordsTest.java index f8c8452..ff5d0f1 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/PasswordsTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/PasswordsTest.java @@ -20,39 +20,43 @@ package org.onap.sdc.security; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; +import org.junit.jupiter.api.Test; + public class PasswordsTest { @Test - public void hashPassword() throws Exception { + public void hashPassword() { String hash = Passwords.hashPassword("hello1234"); assertTrue(Passwords.isExpectedPassword("hello1234", hash)); //test different salt-> result in different hash String hash2 = Passwords.hashPassword("hello1234"); - assertFalse(hash.equals(hash2)); + assertNotEquals(hash, hash2); - String hash3 = Passwords.hashPassword(""); + String hash3 = Passwords.hashPassword(""); assertTrue(Passwords.isExpectedPassword("", hash3)); - String hash4 = Passwords.hashPassword(null); - assertTrue(hash4 == null); + String hash4 = Passwords.hashPassword(null); + assertNull(hash4); } @Test - public void isExpectedPassword() throws Exception { + public void isExpectedPassword() { //region isExpectedPassword(String password, String salt, String hash) assertTrue(Passwords.isExpectedPassword(null, null, null)); //valid hash - assertTrue(Passwords.isExpectedPassword("hello1234", "e0277df331f4ff8f74752ac4a8fbe03b", "6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); + assertTrue(Passwords.isExpectedPassword("hello1234", "e0277df331f4ff8f74752ac4a8fbe03b", + "6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); //invalid salt - assertFalse(Passwords.isExpectedPassword("hello1234", "c0000df331f4ff8f74752ac4a00be03c", "6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); - assertFalse(Passwords.isExpectedPassword("hello1234", null, "6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); + assertFalse(Passwords.isExpectedPassword("hello1234", "c0000df331f4ff8f74752ac4a00be03c", + "6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); + assertFalse(Passwords + .isExpectedPassword("hello1234", null, "6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); //exacly 1 param uninitialized assertFalse(Passwords.isExpectedPassword("hello1234", "", null)); assertFalse(Passwords.isExpectedPassword(null, "", "hello1234")); @@ -63,9 +67,11 @@ public class PasswordsTest { //region isExpectedPassword(String password, String expectedHash) assertTrue(Passwords.isExpectedPassword(null, null)); //valid hash - assertTrue(Passwords.isExpectedPassword("hello1234", "e0277df331f4ff8f74752ac4a8fbe03b:6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); + assertTrue(Passwords.isExpectedPassword("hello1234", + "e0277df331f4ff8f74752ac4a8fbe03b:6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); //invalid salt - assertFalse(Passwords.isExpectedPassword("hello1234", "c0000df331f4ff8f74752ac4a00be03c:6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); + assertFalse(Passwords.isExpectedPassword("hello1234", + "c0000df331f4ff8f74752ac4a00be03c:6dfbad308cdf53c9ff2ee2dca811ee92f1b359586b33027580e2ff92578edbd0")); //exacly 1 param uninitialized assertFalse(Passwords.isExpectedPassword("hello1234", null)); assertFalse(Passwords.isExpectedPassword(null, "hello1234")); diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/RepresentationUtilsTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/RepresentationUtilsTest.java index 26c392e..a5a37d7 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/RepresentationUtilsTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/RepresentationUtilsTest.java @@ -20,35 +20,36 @@ package org.onap.sdc.security; -import org.junit.Test; +import static org.junit.Assert.assertEquals; import java.io.IOException; import java.util.HashSet; import java.util.Set; - -import static org.junit.Assert.assertTrue; +import org.junit.jupiter.api.Test; public class RepresentationUtilsTest { - private static AuthenticationCookie originalCookie = new AuthenticationCookie("kuku"); + private static final AuthenticationCookie originalCookie = new AuthenticationCookie("kuku"); @Test public void representationE2EwithRoleNull() throws IOException { originalCookie.setRoles(null); String jsonStr = RepresentationUtils.toRepresentation(originalCookie); - AuthenticationCookie cookieFromJson = RepresentationUtils.fromRepresentation(jsonStr, AuthenticationCookie.class); - assertTrue(originalCookie.equals(cookieFromJson)); + AuthenticationCookie cookieFromJson = RepresentationUtils + .fromRepresentation(jsonStr, AuthenticationCookie.class); + assertEquals(originalCookie, cookieFromJson); } @Test public void representationE2EwithRoleNotNull() throws IOException { - Set roles = new HashSet(); + Set roles = new HashSet<>(); roles.add("Designer"); roles.add("Admin"); roles.add("Tester"); originalCookie.setRoles(roles); String jsonStr = RepresentationUtils.toRepresentation(originalCookie); - AuthenticationCookie cookieFromJson = RepresentationUtils.fromRepresentation(jsonStr, AuthenticationCookie.class); - assertTrue(originalCookie.equals(cookieFromJson)); + AuthenticationCookie cookieFromJson = RepresentationUtils + .fromRepresentation(jsonStr, AuthenticationCookie.class); + assertEquals(originalCookie, cookieFromJson); } } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/RestUtilsTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/RestUtilsTest.java index bc0ea6f..a55b45d 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/RestUtilsTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/RestUtilsTest.java @@ -20,12 +20,15 @@ package org.onap.sdc.security; -import org.apache.http.HttpHeaders; -import org.junit.Test; -import org.onap.sdc.security.utils.RestUtils; -import static org.junit.Assert.*; +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.assertThrows; import java.util.Properties; +import org.apache.http.HttpHeaders; +import org.junit.jupiter.api.Test; +import org.onap.sdc.security.utils.RestUtils; public class RestUtilsTest { @@ -33,8 +36,8 @@ public class RestUtilsTest { @Test public void addBasicAuthHeaderTest() { Properties headers = new Properties(); - String encryptedPassword = SecurityUtil.INSTANCE.encrypt("password").left().value(); - RestUtils.addBasicAuthHeader(headers, "userName",encryptedPassword); + String encryptedPassword = SecurityUtil.encrypt("password").left().value(); + RestUtils.addBasicAuthHeader(headers, "userName", encryptedPassword); String authHeader = headers.getProperty(HttpHeaders.AUTHORIZATION); assertNotNull(authHeader); assertTrue(authHeader.startsWith("Basic")); @@ -43,18 +46,24 @@ public class RestUtilsTest { @Test public void decryptPasswordSuccessTest() { String decryptedPassword = "password"; - String encryptedPassword = SecurityUtil.INSTANCE.encrypt(decryptedPassword).left().value(); + String encryptedPassword = SecurityUtil.encrypt(decryptedPassword).left().value(); String resultPassword = RestUtils.decryptPassword(encryptedPassword); assertEquals(decryptedPassword, resultPassword); } - @Test(expected = IllegalArgumentException.class) + @Test public void decryptEmptyPasswordTest() { - RestUtils.decryptPassword(""); + assertThrows( + IllegalArgumentException.class, + () -> RestUtils.decryptPassword("") + ); } - @Test(expected = IllegalArgumentException.class) + @Test public void decryptInvalidPasswordTest() { - RestUtils.decryptPassword("enc:9aS3AHtN_pR8QUGu-LPzHC7L8HO43WqOFx2s6nvrYrS"); + assertThrows( + IllegalArgumentException.class, + () -> RestUtils.decryptPassword("enc:9aS3AHtN_pR8QUGu-LPzHC7L8HO43WqOFx2s6nvrYrS") + ); } } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/SecurityUtilTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/SecurityUtilTest.java index f0a21f0..67361a9 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/SecurityUtilTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/SecurityUtilTest.java @@ -20,31 +20,30 @@ package org.onap.sdc.security; -import org.junit.Test; - -import java.util.Base64; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotEquals; +import java.util.Base64; +import org.junit.jupiter.api.Test; + public class SecurityUtilTest { @Test public void encryptDecryptAES128() { String data = "decrypt SUCCESS!!"; - String encrypted = SecurityUtil.INSTANCE.encrypt(data).left().value(); - assertNotEquals( data, encrypted ); + String encrypted = SecurityUtil.encrypt(data).left().value(); + assertNotEquals(data, encrypted); byte[] decryptMsg = Base64.getDecoder().decode(encrypted); - assertEquals( SecurityUtil.INSTANCE.decrypt( decryptMsg , false ).left().value() ,data ); - assertEquals( SecurityUtil.INSTANCE.decrypt( encrypted.getBytes() , true ).left().value() ,data ); + assertEquals(SecurityUtil.decrypt(decryptMsg, false).left().value(), data); + assertEquals(SecurityUtil.decrypt(encrypted.getBytes(), true).left().value(), data); } @Test public void obfuscateKey() { String key = "abcdefghij123456"; String expectedkey = "********ij123456"; - String obfuscated = SecurityUtil.INSTANCE.obfuscateKey( key ); - System.out.println( obfuscated ); - assertEquals( obfuscated , expectedkey ); + String obfuscated = SecurityUtil.obfuscateKey(key); + System.out.println(obfuscated); + assertEquals(obfuscated, expectedkey); } } \ No newline at end of file diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/filters/RestrictionAccessFilterTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/filters/RestrictionAccessFilterTest.java index 20f0d05..6fe7926 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/filters/RestrictionAccessFilterTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/filters/RestrictionAccessFilterTest.java @@ -20,187 +20,193 @@ package org.onap.sdc.security.filters; -import org.apache.http.impl.client.CloseableHttpClient; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; -import org.onap.sdc.security.*; +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.assertThrows; +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; -import javax.servlet.http.Cookie; -import java.io.IOException; -import java.security.InvalidParameterException; import java.util.HashSet; -import static org.junit.Assert.*; -import static org.mockito.Mockito.*; +import javax.servlet.http.Cookie; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.onap.sdc.security.AuthenticationCookie; +import org.onap.sdc.security.ISessionValidationFilterConfiguration; +import org.onap.sdc.security.IUsersThreadLocalHolder; +import org.onap.sdc.security.PortalClient; +import org.onap.sdc.security.RedirectException; -@RunWith(MockitoJUnitRunner.class) -public class RestrictionAccessFilterTest { - private static final String jsonResponseFromPortal = "{\"orgId\":null,\"managerId\":null,\"firstName\":\"NAME\",\"middleInitial\":null,\"lastName\":\"FAMILY\",\"phone\":null,\"email\":\"abc123@test.com\",\"hrid\":null,\"orgUserId\":\"abc123\",\"orgCode\":null,\"orgManagerUserId\":null,\"jobTitle\":null," + - "\"loginId\":\"abc123\",\"active\":true,\"roles\":[%s]}"; - private static final String rolesJson = "{\"id\":\"1234\",\"name\":\"designer\",\"roleFunctions\":[\"read\",\"write\"]}"; +public class RestrictionAccessFilterTest { private static final String userId = "abc123"; - @Mock - private CloseableHttpClient httpClient; - @Mock - private ISessionValidationFilterConfiguration configuration; - @Mock - private ISessionValidationCookieConfiguration cookieConfig; - @Mock - private IUsersThreadLocalHolder threadLocalUtils; - @Mock - private AuthenticationCookie authenticationCookie; - @Mock - private PortalClient portalClient; + private final ISessionValidationFilterConfiguration configuration = Mockito + .mock(ISessionValidationFilterConfiguration.class); + + private final IUsersThreadLocalHolder threadLocalUtils = Mockito.mock(IUsersThreadLocalHolder.class); + + private final AuthenticationCookie authenticationCookie = Mockito.mock(AuthenticationCookie.class); + + private final PortalClient portalClient = Mockito.mock(PortalClient.class); private RestrictionAccessFilter filter; - @Before + @BeforeEach public void setUp() { mockCreateFilter(configuration, threadLocalUtils, portalClient); assertNotNull(filter); } - private void mockCreateFilter(ISessionValidationFilterConfiguration sessionConfig, IUsersThreadLocalHolder threadLocalUtils, PortalClient portalClient) { + private void mockCreateFilter(ISessionValidationFilterConfiguration sessionConfig, + IUsersThreadLocalHolder threadLocalUtils, PortalClient portalClient) { filter = new RestrictionAccessFilter(sessionConfig, threadLocalUtils, portalClient); } -// @Test(expected = InvalidParameterException.class) -// public void filterConfigurationObjectCreationFailedWhenPropertyIsNotSet() { -// when(configuration.getAuthCookie()).thenReturn(cookieConfig); -// when(cookieConfig.getRedirectURL()).thenReturn("does_not_exist"); -// filter = new RestrictionAccessFilter(configuration, portalClient, threadLocalUtils); -// } - - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenUsersDifferent() throws RedirectException { - Cookie[] cookies = new Cookie [1] ; + @Test + public void authorizeUserOnSessionExpirationWhenUsersDifferent() { + Cookie[] cookies = new Cookie[1]; cookies[0] = new Cookie(RestrictionAccessFilter.CSP_USER_ID, "user1"); - filter.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + assertThrows( + RedirectException.class, + () -> filter.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenUserRolesDifferent() throws RedirectException, IOException { + @Test + public void authorizeUserOnSessionExpirationWhenUserRolesDifferent() { when(authenticationCookie.getUserID()).thenReturn(userId); RestrictionAccessFilter spyFilter2 = spy(filter); HashSet roles = new HashSet<>(); roles.add("b"); - Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; + Cookie[] cookies = new Cookie[]{new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; when(authenticationCookie.getRoles()).thenReturn(roles); - spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + assertThrows( + RedirectException.class, + () -> spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenUserRolesDisappearInCookie() throws RedirectException, IOException { + @Test + public void authorizeUserOnSessionExpirationWhenUserRolesDisappearInCookie() { when(authenticationCookie.getUserID()).thenReturn(userId); RestrictionAccessFilter spyFilter2 = spy(filter); HashSet roles = new HashSet<>(); - Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; + Cookie[] cookies = new Cookie[]{new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; when(authenticationCookie.getRoles()).thenReturn(roles); - spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + assertThrows( + RedirectException.class, + () -> spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenUserRolesRetrievedFromPortalAndMatch() throws RedirectException, IOException { + @Test + public void authorizeUserOnSessionExpirationWhenUserRolesRetrievedFromPortalAndMatch() { when(authenticationCookie.getUserID()).thenReturn(userId); - PortalClient spyFilter = spy(portalClient); RestrictionAccessFilter spyFilter2 = spy(filter); HashSet roles = new HashSet<>(); roles.add("DESIGNER"); when(authenticationCookie.getRoles()).thenReturn(roles); - Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; - spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + Cookie[] cookies = new Cookie[]{new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; + assertThrows( + RedirectException.class, + () -> spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenUserRolesRetrievedFromPortalAndEmpty() throws RedirectException, IOException { + @Test + public void authorizeUserOnSessionExpirationWhenUserRolesRetrievedFromPortalAndEmpty() { HashSet roles = new HashSet<>(); roles.add("b"); when(authenticationCookie.getUserID()).thenReturn(userId); when(authenticationCookie.getRoles()).thenReturn(roles); - PortalClient spyFilter = spy(portalClient); RestrictionAccessFilter spyFilter2 = spy(filter); - Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; - spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + Cookie[] cookies = new Cookie[]{new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; + assertThrows( + RedirectException.class, + () -> spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenUserRolesCantBeRetrievedFromPortal() throws RedirectException, IOException { + @Test + public void authorizeUserOnSessionExpirationWhenUserRolesCantBeRetrievedFromPortal() { HashSet roles = new HashSet<>(); roles.add("b"); when(authenticationCookie.getUserID()).thenReturn(userId); when(authenticationCookie.getRoles()).thenReturn(roles); RestrictionAccessFilter spyFilter2 = spy(filter); - Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; - spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + Cookie[] cookies = new Cookie[]{new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; + assertThrows( + RedirectException.class, + () -> spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } -// @Test (expected = RedirectException.class) -// public void authorizeUserOnSessionExpirationWhenHttpRequestFailed() throws RedirectException, IOException, RestrictionAccessFilterException { -// HashSet roles = new HashSet<>(); -// roles.add("b"); -// when(authenticationCookie.getUserID()).thenReturn(userId); -// when(authenticationCookie.getRoles()).thenReturn(roles); -//// PortalClient spyFilter = spy(portalClient); -// RestrictionAccessFilter spyFilter2 = spy(filter); -//// when(spyFilter.fetchUserRolesFromPortal()*/ -// doThrow(IOException.class).when(portalClient).fetchUserRolesFromPortal(eq(userId)); -// Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId)}; -// spyFilter2.authorizeUserOnSessionExpiration(authenticationCookie, cookies); -// } - - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenCspUserCookieIsNull() throws RedirectException, IOException { + @Test + public void authorizeUserOnSessionExpirationWhenCspUserCookieIsNull() { when(authenticationCookie.getUserID()).thenReturn(userId); - Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, null)}; - filter.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + Cookie[] cookies = new Cookie[]{new Cookie(RestrictionAccessFilter.CSP_USER_ID, null)}; + assertThrows( + RedirectException.class, + () -> filter.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } - @Test (expected = RedirectException.class) - public void authorizeUserOnSessionExpirationWhenCookieNotFound() throws RedirectException, IOException { + @Test + public void authorizeUserOnSessionExpirationWhenCookieNotFound() { assertNotNull(filter); - Cookie[] cookies = new Cookie [] {new Cookie("someCookie", userId)}; - filter.authorizeUserOnSessionExpiration(authenticationCookie, cookies); + Cookie[] cookies = new Cookie[]{new Cookie("someCookie", userId)}; + assertThrows( + RedirectException.class, + () -> filter.authorizeUserOnSessionExpiration(authenticationCookie, cookies) + ); } @Test public void getCspUserIdWhenMoreThanOneUserIdExists() throws RedirectException { - Cookie[] cookies = new Cookie [] { - new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId), - new Cookie(RestrictionAccessFilter.CSP_USER_ID, "other")}; + Cookie[] cookies = new Cookie[]{ + new Cookie(RestrictionAccessFilter.CSP_USER_ID, userId), + new Cookie(RestrictionAccessFilter.CSP_USER_ID, "other")}; assertEquals(userId, filter.getCookieValue(cookies, RestrictionAccessFilter.CSP_USER_ID)); } - @Test() + @Test public void getCspUserIdWhenUserIdIsNull() throws RedirectException { - Cookie[] cookies = new Cookie [] {new Cookie(RestrictionAccessFilter.CSP_USER_ID, null)} ; + Cookie[] cookies = new Cookie[]{new Cookie(RestrictionAccessFilter.CSP_USER_ID, null)}; assertNull(filter.getCookieValue(cookies, RestrictionAccessFilter.CSP_USER_ID)); } - @Test(expected=RedirectException.class) - public void getCspUserIdWhenUserIdCookieNotFound() throws RedirectException { - Cookie[] cookies = new Cookie [] {new Cookie("someName", "someValue")} ; - filter.getCookieValue(cookies, RestrictionAccessFilter.CSP_USER_ID); + @Test + public void getCspUserIdWhenUserIdCookieNotFound() { + Cookie[] cookies = new Cookie[]{new Cookie("someName", "someValue")}; + assertThrows( + RedirectException.class, + () -> filter.getCookieValue(cookies, RestrictionAccessFilter.CSP_USER_ID) + ); } - @Test(expected=RedirectException.class) - public void getCspUserIdWhenNoCookiesFound() throws RedirectException { - Cookie[] cookies = new Cookie [] {}; - filter.getCookieValue(cookies, RestrictionAccessFilter.CSP_USER_ID); + @Test + public void getCspUserIdWhenNoCookiesFound() { + Cookie[] cookies = new Cookie[]{}; + assertThrows( + RedirectException.class, + () -> filter.getCookieValue(cookies, RestrictionAccessFilter.CSP_USER_ID) + ); } - @Test(expected=RedirectException.class) - public void getCspUserIdWhenCookiesNull() throws RedirectException { - filter.getCookieValue(null, RestrictionAccessFilter.CSP_USER_ID); + @Test + public void getCspUserIdWhenCookiesNull() { + assertThrows( + RedirectException.class, + () -> filter.getCookieValue(null, RestrictionAccessFilter.CSP_USER_ID) + ); } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/filters/SessionValidationFilterTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/filters/SessionValidationFilterTest.java index 9c5fd89..c92d086 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/filters/SessionValidationFilterTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/filters/SessionValidationFilterTest.java @@ -20,52 +20,43 @@ package org.onap.sdc.security.filters; -import org.junit.Before; -import org.junit.FixMethodOrder; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.MethodSorters; -import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.Mockito; -import org.mockito.Spy; -import org.mockito.junit.MockitoJUnitRunner; -import org.onap.sdc.security.AuthenticationCookie; -import org.onap.sdc.security.AuthenticationCookieUtils; -import org.onap.sdc.security.CipherUtilException; -import org.onap.sdc.security.RepresentationUtils; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.when; +import java.io.IOException; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.servlet.http.Cookie; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; -import java.io.IOException; - -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.when; +import org.junit.FixMethodOrder; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.runners.MethodSorters; +import org.mockito.Mockito; +import org.onap.sdc.security.AuthenticationCookie; +import org.onap.sdc.security.AuthenticationCookieUtils; +import org.onap.sdc.security.CipherUtilException; +import org.onap.sdc.security.RepresentationUtils; -@RunWith(MockitoJUnitRunner.class) @FixMethodOrder(MethodSorters.NAME_ASCENDING) public class SessionValidationFilterTest { - @Mock - private HttpServletRequest request; - @Spy - private HttpServletResponse response; - @Mock - private FilterChain filterChain; - @Mock - private FilterConfig filterConfig; + + private final HttpServletRequest request = Mockito.mock(HttpServletRequest.class); + + private final HttpServletResponse response = Mockito.spy(HttpServletResponse.class); + + private final FilterChain filterChain = Mockito.mock(FilterChain.class); + + private final FilterConfig filterConfig = Mockito.mock(FilterConfig.class); // implementation of SessionValidationFilter - @InjectMocks - @Spy - private SampleFilter sessionValidationFilter = new SampleFilter(); + private final SampleFilter sessionValidationFilter = Mockito.spy(SampleFilter.class); - @Before - public void setUpClass() throws ServletException { + @BeforeEach + public void setUpClass() { sessionValidationFilter.init(filterConfig); } @@ -111,23 +102,28 @@ public class SessionValidationFilterTest { @Test public void noCookiesWithCorrectNameInRequest() throws IOException, ServletException { when(request.getPathInfo()).thenReturn("/resource"); - String newNameNotContainsRealName = sessionValidationFilter.getFilterConfiguration().getCookieName().substring(1); - Cookie cookie = new Cookie("fake" + newNameNotContainsRealName + "fake2", RepresentationUtils.toRepresentation(new AuthenticationCookie("kuku"))); + String newNameNotContainsRealName = sessionValidationFilter.getFilterConfiguration().getCookieName() + .substring(1); + Cookie cookie = new Cookie("fake" + newNameNotContainsRealName + "fake2", + RepresentationUtils.toRepresentation(new AuthenticationCookie("kuku"))); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); Mockito.verify(sessionValidationFilter, times(1)).handleRedirectException(response); } @Test - public void cookieMaxSessionTimedOutAndUserIsNotAuthorized() throws IOException, ServletException, CipherUtilException { + public void cookieMaxSessionTimedOutAndUserIsNotAuthorized() + throws IOException, ServletException, CipherUtilException { when(request.getPathInfo()).thenReturn("/resource"); AuthenticationCookie authenticationCookie = new AuthenticationCookie(SampleFilter.FAILED_ON_USER_AUTH); // set max session time to timout value long maxSessionTimeOut = sessionValidationFilter.getFilterConfiguration().getMaxSessionTimeOut(); long startTime = authenticationCookie.getMaxSessionTime(); - long timeout = startTime - maxSessionTimeOut - 1000l; + long timeout = startTime - maxSessionTimeOut - 1000L; authenticationCookie.setMaxSessionTime(timeout); - Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); @@ -135,15 +131,18 @@ public class SessionValidationFilterTest { } @Test - public void cookieMaxSessionTimedOutAndUserIsAuthorized() throws IOException, ServletException, CipherUtilException { + public void cookieMaxSessionTimedOutAndUserIsAuthorized() + throws IOException, ServletException, CipherUtilException { when(request.getPathInfo()).thenReturn("/resource"); AuthenticationCookie authenticationCookie = new AuthenticationCookie("userId"); // set max session time to timout value long maxSessionTimeOut = sessionValidationFilter.getFilterConfiguration().getMaxSessionTimeOut(); long startTime = authenticationCookie.getMaxSessionTime(); - long timeout = startTime - maxSessionTimeOut - 1000l; + long timeout = startTime - maxSessionTimeOut - 1000L; authenticationCookie.setMaxSessionTime(timeout); - Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); @@ -159,7 +158,9 @@ public class SessionValidationFilterTest { long sessionStartTime = authenticationCookie.getCurrentSessionTime(); long timeout = sessionStartTime - idleSessionTimeOut - 2000; authenticationCookie.setCurrentSessionTime(timeout); - Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); @@ -175,7 +176,9 @@ public class SessionValidationFilterTest { long sessionStartTime = authenticationCookie.getCurrentSessionTime(); long timeout = sessionStartTime - idleSessionTimeOut - 2000; authenticationCookie.setCurrentSessionTime(timeout); - Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); @@ -183,10 +186,13 @@ public class SessionValidationFilterTest { } @Test - public void cookieSessionIsNotExpiredRoleAssignmentDone() throws IOException, ServletException, CipherUtilException { + public void cookieSessionIsNotExpiredRoleAssignmentDone() + throws IOException, ServletException, CipherUtilException { when(request.getPathInfo()).thenReturn("/resource"); AuthenticationCookie authenticationCookie = new AuthenticationCookie(SampleFilter.FAILED_ON_ROLE); - Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); @@ -199,20 +205,25 @@ public class SessionValidationFilterTest { when(request.getPathInfo()).thenReturn("/resource"); AuthenticationCookie authenticationCookie = new AuthenticationCookie("kuku"); - Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); Mockito.verify(filterChain, times(1)).doFilter(request, response); } -// test validate contains + // test validate contains @Test - public void requestThatPassFilterWithCookieNameAsPartOfOtherString() throws IOException, ServletException, CipherUtilException { + public void requestThatPassFilterWithCookieNameAsPartOfOtherString() + throws IOException, ServletException, CipherUtilException { when(request.getPathInfo()).thenReturn("/resource"); AuthenticationCookie authenticationCookie = new AuthenticationCookie("kuku"); - Cookie cookie = new Cookie("some" +sessionValidationFilter.getFilterConfiguration().getCookieName() + "Thing", AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie("some" + sessionValidationFilter.getFilterConfiguration().getCookieName() + "Thing", + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); sessionValidationFilter.doFilter(request, response, filterChain); @@ -224,7 +235,9 @@ public class SessionValidationFilterTest { when(request.getPathInfo()).thenReturn("/resource"); AuthenticationCookie authenticationCookie = new AuthenticationCookie("kuku"); - Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), AuthenticationCookieUtils.getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); + Cookie cookie = new Cookie(sessionValidationFilter.getFilterConfiguration().getCookieName(), + AuthenticationCookieUtils + .getEncryptedCookie(authenticationCookie, sessionValidationFilter.getFilterConfiguration())); when(request.getCookies()).thenReturn(new Cookie[]{cookie}); String oldKey = sessionValidationFilter.getFilterConfiguration().getSecurityKey(); diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/elements/LogFieldsMdcHandlerTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/elements/LogFieldsMdcHandlerTest.java index bb95d15..ea1f6b7 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/elements/LogFieldsMdcHandlerTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/elements/LogFieldsMdcHandlerTest.java @@ -14,16 +14,6 @@ */ package org.onap.sdc.security.logging.elements; -import org.junit.Before; -import org.junit.Test; -import org.onap.logging.ref.slf4j.ONAPLogConstants; -import org.onap.sdc.security.logging.api.ILogConfiguration; -import org.onap.sdc.security.logging.enums.EcompHeadersConstants; -import org.onap.sdc.security.logging.enums.Severity; -import org.slf4j.MDC; - -import javax.servlet.http.HttpServletRequest; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; @@ -37,12 +27,22 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import javax.servlet.http.HttpServletRequest; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.onap.logging.ref.slf4j.ONAPLogConstants; +import org.onap.sdc.security.logging.api.ILogConfiguration; +import org.onap.sdc.security.logging.enums.EcompHeadersConstants; +import org.onap.sdc.security.logging.enums.Severity; +import org.slf4j.MDC; + public class LogFieldsMdcHandlerTest { + LogFieldsMdcHandler instanceMdcWrapper; LogFieldsMdcHandler spy; - @Before - public void setUp() throws Exception { + @BeforeEach + public void setUp() { LogFieldsMdcHandler.hostAddress = "TestHost"; LogFieldsMdcHandler.fqdn = "Test"; instanceMdcWrapper = LogFieldsMdcHandler.getInstance(); @@ -144,7 +144,7 @@ public class LogFieldsMdcHandlerTest { spy.setAlertSeverity(Severity.CRITICAL); verify(spy, times(1)).setAlertSeverity(any(Severity.class)); assertEquals(String.valueOf(Severity.CRITICAL.getSeverityType()), - MDC.get(ONAPLogConstants.MDCs.RESPONSE_SEVERITY)); + MDC.get(ONAPLogConstants.MDCs.RESPONSE_SEVERITY)); } @Test @@ -441,7 +441,7 @@ public class LogFieldsMdcHandlerTest { public void collectRequestInfoForErrorAndDebugLogging() { HttpServletRequest httpRequest = mock(HttpServletRequest.class); when(httpRequest.getHeader(EcompHeadersConstants.X_ECOMP_SERVICE_ID_HEADER)).thenReturn( - "MockServiceInstanceID"); + "MockServiceInstanceID"); when(httpRequest.getHeader(EcompHeadersConstants.USER_ID_HEADER)).thenReturn("Mock_User"); when(httpRequest.getRemoteHost()).thenReturn("Test_Host"); when(httpRequest.getLocalAddr()).thenReturn("172.0.0.0"); @@ -450,12 +450,12 @@ public class LogFieldsMdcHandlerTest { spy.collectRequestInfoForErrorAndDebugLogging(httpRequest); verify(spy, times(1)). - collectRequestInfoForErrorAndDebugLogging(any(HttpServletRequest.class)); + collectRequestInfoForErrorAndDebugLogging(any(HttpServletRequest.class)); assertEquals("Test_Service", spy.getServiceName()); assertEquals("Test_ID", spy.getKeyRequestId()); assertEquals("Test_Host", spy.getRemoteHost()); assertEquals("172.0.0.0", spy.getServerIpAddress()); - assertEquals("MockServiceInstanceID", MDC.get(ILogConfiguration.MDC_SERVICE_INSTANCE_ID) ); + assertEquals("MockServiceInstanceID", MDC.get(ILogConfiguration.MDC_SERVICE_INSTANCE_ID)); assertEquals("Mock_User", spy.getPartnerName()); } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/EcompLoggerErrorCodeTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/EcompLoggerErrorCodeTest.java index 1bdbddf..2522c11 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/EcompLoggerErrorCodeTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/EcompLoggerErrorCodeTest.java @@ -24,7 +24,7 @@ package org.onap.sdc.security.logging.enums; import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class EcompLoggerErrorCodeTest { @@ -32,19 +32,19 @@ public class EcompLoggerErrorCodeTest { public void getByValueTest() { EcompLoggerErrorCode ecompLoggerErrorCode = EcompLoggerErrorCode.getByValue("E_0"); - Assert.assertEquals(ecompLoggerErrorCode.getErrorCode(), 0); + Assert.assertEquals(0, ecompLoggerErrorCode.getErrorCode()); ecompLoggerErrorCode = EcompLoggerErrorCode.getByValue("E_100"); - Assert.assertEquals(ecompLoggerErrorCode.getErrorCode(), 100); + Assert.assertEquals(100, ecompLoggerErrorCode.getErrorCode()); ecompLoggerErrorCode = EcompLoggerErrorCode.getByValue("E_200"); - Assert.assertEquals(ecompLoggerErrorCode.getErrorCode(), 200); + Assert.assertEquals(200, ecompLoggerErrorCode.getErrorCode()); ecompLoggerErrorCode = EcompLoggerErrorCode.getByValue("E_300"); - Assert.assertEquals(ecompLoggerErrorCode.getErrorCode(), 300); + Assert.assertEquals(300, ecompLoggerErrorCode.getErrorCode()); ecompLoggerErrorCode = EcompLoggerErrorCode.getByValue("E_400"); - Assert.assertEquals(ecompLoggerErrorCode.getErrorCode(), 400); + Assert.assertEquals(400, ecompLoggerErrorCode.getErrorCode()); ecompLoggerErrorCode = EcompLoggerErrorCode.getByValue("E_500"); - Assert.assertEquals(ecompLoggerErrorCode.getErrorCode(), 500); + Assert.assertEquals(500, ecompLoggerErrorCode.getErrorCode()); ecompLoggerErrorCode = EcompLoggerErrorCode.getByValue("none"); - Assert.assertEquals(ecompLoggerErrorCode.getErrorCode(), 900); + Assert.assertEquals(900, ecompLoggerErrorCode.getErrorCode()); } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/LoggerSupportabilityActionsTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/LoggerSupportabilityActionsTest.java index 5f63c7a..b36ad72 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/LoggerSupportabilityActionsTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/LoggerSupportabilityActionsTest.java @@ -21,25 +21,24 @@ */ package org.onap.sdc.security.logging.enums; -import org.junit.Test; - import static org.junit.Assert.assertEquals; +import org.junit.jupiter.api.Test; + public class LoggerSupportabilityActionsTest { @Test public void testGetName() { - assertEquals(LoggerSupportabilityActions.ARCHIVE.getName(), "ARCHIVE"); - assertEquals(LoggerSupportabilityActions.ASSOCIATE_RI_TO_RI.getName(), - "ASSOCIATE RI TO RI"); - assertEquals(LoggerSupportabilityActions.CHANGELIFECYCLESTATE.getName(), - "CHANGE LIFECYCLE STATE"); - assertEquals(LoggerSupportabilityActions.CREATE_ARTIFACTS.getName(), "ADD ARTIFACTS"); - assertEquals(LoggerSupportabilityActions.CREATE_CAPABILITY_REQUIREMENTS.getName(), - "CREATE CAPABILITY REQUIREMENTS"); - assertEquals(LoggerSupportabilityActions.CREATE_GROUP_POLICY.getName(), "ADD GROUP POLICY"); - assertEquals(LoggerSupportabilityActions.CREATE_GROUPS.getName(), "ADD GROUPS"); - + assertEquals("ARCHIVE", LoggerSupportabilityActions.ARCHIVE.getName()); + assertEquals("ASSOCIATE RI TO RI", + LoggerSupportabilityActions.ASSOCIATE_RI_TO_RI.getName()); + assertEquals("CHANGE LIFECYCLE STATE", + LoggerSupportabilityActions.CHANGELIFECYCLESTATE.getName()); + assertEquals("ADD ARTIFACTS", LoggerSupportabilityActions.CREATE_ARTIFACTS.getName()); + assertEquals("CREATE CAPABILITY REQUIREMENTS", + LoggerSupportabilityActions.CREATE_CAPABILITY_REQUIREMENTS.getName()); + assertEquals("ADD GROUP POLICY", LoggerSupportabilityActions.CREATE_GROUP_POLICY.getName()); + assertEquals("ADD GROUPS", LoggerSupportabilityActions.CREATE_GROUPS.getName()); } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/SeverityTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/SeverityTest.java index 7ef4190..dff7665 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/SeverityTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/SeverityTest.java @@ -22,18 +22,18 @@ package org.onap.sdc.security.logging.enums; -import org.junit.Test; - import static org.junit.Assert.assertEquals; +import org.junit.jupiter.api.Test; + public class SeverityTest { @Test public void testGetSeverityType() { - assertEquals(Severity.OK.getSeverityType(), 0); - assertEquals(Severity.WARNING.getSeverityType(), 1); - assertEquals(Severity.CRITICAL.getSeverityType(), 2); - assertEquals(Severity.DOWN.getSeverityType(), 3); - assertEquals(Severity.UNREACHABLE.getSeverityType(), 4); + assertEquals(0, Severity.OK.getSeverityType()); + assertEquals(1, Severity.WARNING.getSeverityType()); + assertEquals(2, Severity.CRITICAL.getSeverityType()); + assertEquals(3, Severity.DOWN.getSeverityType()); + assertEquals(4, Severity.UNREACHABLE.getSeverityType()); } } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/StatusCodeTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/StatusCodeTest.java index 72cf01c..1fefec5 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/StatusCodeTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/enums/StatusCodeTest.java @@ -22,18 +22,18 @@ package org.onap.sdc.security.logging.enums; -import org.junit.Test; - import static org.junit.Assert.assertEquals; +import org.junit.jupiter.api.Test; + public class StatusCodeTest { @Test public void testGetStatusCodeEnum() { - assertEquals(StatusCode.ERROR.getStatusCodeEnum(), "ERROR"); - assertEquals(StatusCode.STARTED.getStatusCodeEnum(), "STARTED"); - assertEquals(StatusCode.COMPLETE.getStatusCodeEnum(), "COMPLETE"); - assertEquals(StatusCode.INPROGRESS.getStatusCodeEnum(), "INPROGRESS"); + assertEquals("ERROR", StatusCode.ERROR.getStatusCodeEnum()); + assertEquals("STARTED", StatusCode.STARTED.getStatusCodeEnum()); + assertEquals("COMPLETE", StatusCode.COMPLETE.getStatusCodeEnum()); + assertEquals("INPROGRESS", StatusCode.INPROGRESS.getStatusCodeEnum()); } } diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcAuditTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcAuditTest.java index a8eab4c..67412b4 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcAuditTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcAuditTest.java @@ -14,22 +14,6 @@ */ package org.onap.sdc.security.logging.wrappers; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.onap.logging.ref.slf4j.ONAPLogConstants; -import org.onap.sdc.security.logging.enums.LogLevel; -import org.onap.sdc.security.logging.enums.Severity; -import org.slf4j.MDC; -import org.slf4j.Marker; -import org.slf4j.MarkerFactory; - -import javax.ws.rs.container.ContainerRequestContext; -import javax.ws.rs.core.Response; -import javax.ws.rs.core.UriInfo; -import java.net.URI; -import java.net.URISyntaxException; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -41,18 +25,34 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import java.net.URI; +import java.net.URISyntaxException; +import javax.ws.rs.container.ContainerRequestContext; +import javax.ws.rs.core.Response; +import javax.ws.rs.core.UriInfo; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.onap.logging.ref.slf4j.ONAPLogConstants; +import org.onap.sdc.security.logging.enums.LogLevel; +import org.onap.sdc.security.logging.enums.Severity; +import org.slf4j.MDC; +import org.slf4j.Marker; +import org.slf4j.MarkerFactory; + public class LoggerSdcAuditTest { + LoggerSdcAudit spy; private Marker marker; - @Before + @BeforeEach public void setUp() { LoggerSdcAudit audit = new LoggerSdcAudit(this.getClass()); spy = spy(audit); marker = MarkerFactory.getMarker(ONAPLogConstants.Markers.ENTRY.getName()); } - @After + @AfterEach public void tearDown() { MDC.clear(); } @@ -106,7 +106,7 @@ public class LoggerSdcAuditTest { spy.logExit("172.0.0.0", mockContext, mockStatus, LogLevel.INFO, Severity.WARNING, "MockMessage", marker); assertEquals("false", MDC.get("auditOn")); verify(spy, times(1)).logExit(anyString(), any(ContainerRequestContext.class), any(Response.StatusType.class) - , any(LogLevel.class), any(Severity.class), anyString(), any(Marker.class)); + , any(LogLevel.class), any(Severity.class), anyString(), any(Marker.class)); } @Test @@ -124,7 +124,7 @@ public class LoggerSdcAuditTest { spy.logEntry("172.0.0.0", mockContext, LogLevel.INFO, Severity.WARNING, "MockMessage", marker); assertEquals("false", MDC.get("auditOn")); verify(spy, times(1)).logEntry(anyString(), any(ContainerRequestContext.class) - , any(LogLevel.class), any(Severity.class), anyString(), any(Marker.class)); + , any(LogLevel.class), any(Severity.class), anyString(), any(Marker.class)); } @Test @@ -132,6 +132,6 @@ public class LoggerSdcAuditTest { spy.logEntry(LogLevel.INFO, Severity.WARNING, "MockMessage", marker, "RequestID"); assertEquals("false", MDC.get("auditOn")); verify(spy, times(1)) - .logEntry(any(LogLevel.class), any(Severity.class), anyString(), any(Marker.class), anyString()); + .logEntry(any(LogLevel.class), any(Severity.class), anyString(), any(Marker.class), anyString()); } } \ No newline at end of file diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcUtilBaseTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcUtilBaseTest.java index 10b88c5..7c16999 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcUtilBaseTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerSdcUtilBaseTest.java @@ -14,24 +14,12 @@ */ package org.onap.sdc.security.logging.wrappers; -import org.apache.commons.lang3.StringUtils; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mockito; -import org.onap.sdc.security.logging.enums.EcompLoggerErrorCode; - -import javax.ws.rs.container.ContainerRequestContext; -import javax.ws.rs.core.UriInfo; -import java.net.URI; -import java.net.URISyntaxException; -import java.util.Arrays; - 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.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyInt; import static org.mockito.ArgumentMatchers.anyList; import static org.mockito.ArgumentMatchers.anyString; import static org.mockito.Mockito.mock; @@ -40,10 +28,21 @@ import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.Arrays; +import javax.ws.rs.container.ContainerRequestContext; +import javax.ws.rs.core.UriInfo; +import org.apache.commons.lang3.StringUtils; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.onap.sdc.security.logging.enums.EcompLoggerErrorCode; + public class LoggerSdcUtilBaseTest { + private LoggerSdcUtilBase spy; - @Before + @BeforeEach public void setUp() { LoggerSdcUtilBase loggerSdcUtilBase = new LoggerSdcUtilBase(); spy = spy(loggerSdcUtilBase); @@ -60,7 +59,7 @@ public class LoggerSdcUtilBaseTest { @Test public void convertHttpCodeToErrorCode() { - assertEquals( EcompLoggerErrorCode.SUCCESS ,spy.convertHttpCodeToErrorCode(398)); + assertEquals(EcompLoggerErrorCode.SUCCESS, spy.convertHttpCodeToErrorCode(398)); assertEquals(EcompLoggerErrorCode.SCHEMA_ERROR, spy.convertHttpCodeToErrorCode(409)); assertEquals(EcompLoggerErrorCode.UNKNOWN_ERROR, spy.convertHttpCodeToErrorCode(421)); assertEquals(EcompLoggerErrorCode.DATA_ERROR, spy.convertHttpCodeToErrorCode(415)); diff --git a/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerTest.java b/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerTest.java index 1288578..0912920 100644 --- a/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerTest.java +++ b/security-util-lib/src/test/java/org/onap/sdc/security/logging/wrappers/LoggerTest.java @@ -14,18 +14,6 @@ */ package org.onap.sdc.security.logging.wrappers; -import org.junit.Before; -import org.junit.Test; -import org.onap.logging.ref.slf4j.ONAPLogConstants; -import org.onap.sdc.security.logging.elements.ErrorLogOptionalData; -import org.onap.sdc.security.logging.enums.EcompErrorSevirity; -import org.onap.sdc.security.logging.enums.EcompLoggerErrorCode; -import org.slf4j.Marker; -import org.slf4j.MarkerFactory; - -import java.util.Arrays; -import java.util.List; - import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; @@ -37,14 +25,26 @@ import static org.mockito.Mockito.spy; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; +import java.util.Arrays; +import java.util.List; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.onap.logging.ref.slf4j.ONAPLogConstants; +import org.onap.sdc.security.logging.elements.ErrorLogOptionalData; +import org.onap.sdc.security.logging.enums.EcompErrorSevirity; +import org.onap.sdc.security.logging.enums.EcompLoggerErrorCode; +import org.slf4j.Marker; +import org.slf4j.MarkerFactory; + public class LoggerTest { + Logger log; Logger spy; Marker marker; List testList; - @Before - public void setUp() throws Exception { + @BeforeEach + public void setUp() { testList = Arrays.asList("Item1", "Item2"); marker = MarkerFactory.getMarker(ONAPLogConstants.Markers.ENTRY.getName()); log = Logger.getLogger(LoggerTest.class.getName()); @@ -96,38 +96,42 @@ public class LoggerTest { @Test public void testInfoWithObject() { - spy.info("Test Info log", testList); - verify(spy, times(1)).info("Test Info log", testList); + spy.info("Test Info log - {}", testList); + verify(spy, times(1)).info("Test Info log - {}", testList); } @Test public void testInfoWith2Object() { - spy.info("Test Info log", testList, testList); - verify(spy, times(1)).info("Test Info log", testList, testList); + spy.info("Test Info log - {} - {}", testList, testList); + verify(spy, times(1)).info("Test Info log - {} - {}", testList, testList); } @Test public void debug() { - spy.debug("Test DEBUG log", testList); + spy.debug("Test DEBUG log - {}", testList); verify(spy, times(1)).debug(anyString(), any(Object.class)); } @Test public void metric() { - spy.metric("Test metric log", testList); + spy.metric("Test metric log - {}", testList); verify(spy, times(1)).metric(anyString(), any(Object.class)); } @Test public void invoke() { spy.invoke("Test Host", "Test Entity", "Test Service", "Test metric log", testList, testList, testList); - verify(spy, times(1)).invoke(anyString(), anyString(), anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); + verify(spy, times(1)) + .invoke(anyString(), anyString(), anyString(), anyString(), anyCollection(), anyCollection(), + anyCollection()); } @Test public void invokeReturn() { spy.invokeReturn(ONAPLogConstants.ResponseStatus.ERROR, "Test metric log", testList, testList, testList); - verify(spy, times(1)).invokeReturn(any(ONAPLogConstants.ResponseStatus.class), anyString(), anyCollection(), anyCollection(), anyCollection()); + verify(spy, times(1)) + .invokeReturn(any(ONAPLogConstants.ResponseStatus.class), anyString(), anyCollection(), anyCollection(), + anyCollection()); } @Test @@ -161,19 +165,19 @@ public class LoggerTest { @Test public void testDebugMarkerWithParam() { - spy.debug(marker, "Test marker debug log", testList); + spy.debug(marker, "Test marker debug log - {}", testList); verify(spy, times(1)).debug(any(Marker.class), anyString(), anyCollection()); } @Test public void testDebugMarkerWithMultipleObjects() { - spy.debug(marker, "Test marker debug log", testList, testList, testList); + spy.debug(marker, "Test marker debug log - {} - {} - {}", testList, testList, testList); verify(spy, times(1)).debug(any(Marker.class), anyString(), anyCollection(), anyCollection(), anyCollection()); } @Test public void testDebugWithMarker2Params() { - spy.debug(marker, "Test marker debug log", testList, testList); + spy.debug(marker, "Test marker debug log - {} - {}", testList, testList); verify(spy, times(1)).debug(any(Marker.class), anyString(), anyCollection(), anyCollection()); } @@ -191,19 +195,19 @@ public class LoggerTest { @Test public void testDebugWithParam() { - spy.debug("Test debug log", testList); + spy.debug("Test debug log - {}", testList); verify(spy, times(1)).debug(anyString(), anyCollection()); } @Test public void testDebugWith2Params() { - spy.debug("Test debug log", testList, testList); + spy.debug("Test debug log - {} - {}", testList, testList); verify(spy, times(1)).debug(anyString(), anyCollection(), anyCollection()); } @Test public void trace() { - spy.trace("Test trace log", testList, testList, testList); + spy.trace("Test trace log - {} - {} - {}", testList, testList, testList); verify(spy, times(1)).trace(anyString(), anyCollection(), anyCollection(), anyCollection()); } @@ -226,19 +230,19 @@ public class LoggerTest { @Test public void testTraceMarkerWithParam() { - spy.trace(marker, "Test trace log", testList); + spy.trace(marker, "Test trace log - {}", testList); verify(spy, times(1)).trace(any(Marker.class), anyString(), anyCollection()); } @Test public void testTraceMarkerWith2Params() { - spy.trace(marker, "Test trace log", testList, testList); + spy.trace(marker, "Test trace log - {} - {}", testList, testList); verify(spy, times(1)).trace(any(Marker.class), anyString(), anyCollection(), anyCollection()); } @Test public void testTraceMarkerWithMultipleParams() { - spy.trace(marker, "Test trace log", testList, testList, testList); + spy.trace(marker, "Test trace log - {} - {} - {}", testList, testList, testList); verify(spy, times(1)).trace(any(Marker.class), anyString(), anyCollection(), anyCollection(), anyCollection()); } @@ -256,19 +260,19 @@ public class LoggerTest { @Test public void testTraceWithParam() { - spy.trace("Test trace log", testList); + spy.trace("Test trace log - {}", testList); verify(spy, times(1)).trace(anyString(), anyCollection()); } @Test public void testTraceWith2Params() { - spy.trace("Test trace log", testList, testList); + spy.trace("Test trace log - {} - {}", testList, testList); verify(spy, times(1)).trace(anyString(), anyCollection(), anyCollection()); } @Test public void testInfoWithMultipleObjects() { - spy.info("Test Info log", testList, testList, testList); + spy.info("Test Info log - {} - {} - {}", testList, testList, testList); verify(spy, times(1)).info(anyString(), anyCollection(), anyCollection(), anyCollection()); } @@ -291,19 +295,19 @@ public class LoggerTest { @Test public void testInfoMarkerWithParam() { - spy.info(marker, "Test info log", testList); + spy.info(marker, "Test info log - {}", testList); verify(spy, times(1)).info(any(Marker.class), anyString(), anyCollection()); } @Test public void testInfoMarkerWith2Params() { - spy.info(marker, "Test info log", testList, testList); + spy.info(marker, "Test info log - {} - {}", testList, testList); verify(spy, times(1)).info(any(Marker.class), anyString(), anyCollection(), anyCollection()); } @Test public void testInfoMarkerWithMultipleParams() { - spy.info(marker, "Test info log", testList, testList, testList); + spy.info(marker, "Test info log - {} - {} - {}", testList, testList, testList); verify(spy, times(1)).info(any(Marker.class), anyString(), anyCollection(), anyCollection(), anyCollection()); } @@ -326,70 +330,73 @@ public class LoggerTest { @Test public void testErrorWithSeverity() { spy.error(EcompErrorSevirity.ERROR, EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", "MockTargetEntity", - "Test error description", testList, testList, testList); + "Mock Service", "MockTargetEntity", + "Test error description", testList, testList, testList); verify(spy, times(1)).error(any(EcompErrorSevirity.class), any(EcompLoggerErrorCode.class), - anyString(), anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); } @Test public void testError() { spy.error(EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", "Test error description", testList, testList, testList); + "Mock Service - {} - {} - {} - {}", "Test error description", testList, testList, testList); verify(spy, times(1)).error(any(EcompLoggerErrorCode.class), - anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); } @Test public void testErrorOptionalData() { spy.error(EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", ErrorLogOptionalData.newBuilder().build(), - "Test error description", testList, testList, testList); + "Mock Service - {} - {} - {} - {} - {}", ErrorLogOptionalData.newBuilder().build(), + "Test error description", testList, testList, testList); verify(spy, times(1)).error(any(EcompLoggerErrorCode.class), - anyString(), any(ErrorLogOptionalData.class), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), any(ErrorLogOptionalData.class), anyString(), anyCollection(), anyCollection(), + anyCollection()); } @Test public void testWarn() { spy.warn(EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", "Test warn description", testList, testList, testList); + "Mock Service - {} - {} - {} - {}", "Test warn description", testList, testList, testList); verify(spy, times(1)).warn(any(EcompLoggerErrorCode.class), - anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); } @Test public void testWarnWithTargetEntity() { spy.warn(EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", "MockTargetEntity", - "Test warn description", testList, testList, testList); + "Mock Service - {} - {} - {} - {} - {}", "MockTargetEntity", + "Test warn description", testList, testList, testList); verify(spy, times(1)).warn(any(EcompLoggerErrorCode.class), - anyString(), anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); } @Test public void testWarnOptionalData() { spy.warn(EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", ErrorLogOptionalData.newBuilder().build(), - "Test warn description", testList, testList, testList); + "Mock Service - {} - {} - {} - {} - {}", ErrorLogOptionalData.newBuilder().build(), + "Test warn description", testList, testList, testList); verify(spy, times(1)).warn(any(EcompLoggerErrorCode.class), - anyString(), any(ErrorLogOptionalData.class), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), any(ErrorLogOptionalData.class), anyString(), anyCollection(), anyCollection(), + anyCollection()); } @Test public void testFatalWithTargetEntity() { spy.fatal(EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", "MockTargetEntity", - "Test fatal description", testList, testList, testList); + "Mock Service - {} - {} - {} - {} - {}", "MockTargetEntity", + "Test fatal description", testList, testList, testList); verify(spy, times(1)).fatal(any(EcompLoggerErrorCode.class), - anyString(), anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), anyString(), anyString(), anyCollection(), anyCollection(), anyCollection()); } @Test public void testFatalWithOptionalData() { spy.fatal(EcompLoggerErrorCode.UNKNOWN_ERROR, - "Mock Service", ErrorLogOptionalData.newBuilder().build(), - "Test fatal description", testList, testList, testList); + "Mock Service - {} - {} - {} - {} - {}", ErrorLogOptionalData.newBuilder().build(), + "Test fatal description", testList, testList, testList); verify(spy, times(1)).fatal(any(EcompLoggerErrorCode.class), - anyString(), any(ErrorLogOptionalData.class), anyString(), anyCollection(), anyCollection(), anyCollection()); + anyString(), any(ErrorLogOptionalData.class), anyString(), anyCollection(), anyCollection(), + anyCollection()); } } \ No newline at end of file diff --git a/session-lib/src/test/java/org/onap/sdc/common/session/SdcSessionContextProviderTest.java b/session-lib/src/test/java/org/onap/sdc/common/session/SdcSessionContextProviderTest.java index 7aa002a..a118973 100644 --- a/session-lib/src/test/java/org/onap/sdc/common/session/SdcSessionContextProviderTest.java +++ b/session-lib/src/test/java/org/onap/sdc/common/session/SdcSessionContextProviderTest.java @@ -17,10 +17,11 @@ package org.onap.sdc.common.session; import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; -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.onap.sdc.common.session.impl.SdcSessionContextProvider; import org.onap.sdc.common.session.impl.SessionException; @@ -28,21 +29,27 @@ public class SdcSessionContextProviderTest { private SdcSessionContextProvider sdcSessionContextProvider; - @Before + @BeforeEach public void init() { sdcSessionContextProvider = new SdcSessionContextProvider(); } - @Test(expected = SessionException.class) + @Test public void createSessionNoTenant() { sdcSessionContextProvider.create("user", null); - sdcSessionContextProvider.get(); + assertThrows( + SessionException.class, + () -> sdcSessionContextProvider.get() + ); } - @Test(expected = SessionException.class) + @Test public void createSessionNoUser() { sdcSessionContextProvider.create(null, "t1"); - sdcSessionContextProvider.get(); + assertThrows( + SessionException.class, + () -> sdcSessionContextProvider.get() + ); } @Test @@ -55,7 +62,7 @@ public class SdcSessionContextProviderTest { assertEquals(tenant, sessionContext.getTenant()); } - @After + @AfterEach public void cleanup() { sdcSessionContextProvider.close(); } diff --git a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java index 1689182..c131b9d 100644 --- a/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java +++ b/versioning-lib/src/main/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImpl.java @@ -40,8 +40,6 @@ import org.springframework.stereotype.Service; @Service public class VersioningManagerImpl implements VersioningManager { - //private static final Logger LOGGER = LoggerFactory.getLogger(VersioningManagerImpl.class); - private final ItemDao itemDao; private final VersionDao versionDao; private final VersionCalculator versionCalculator; @@ -107,8 +105,8 @@ public class VersioningManagerImpl implements VersioningManager { VersionStatus prevStatus = version.getStatus(); if (prevStatus == status) { throw new VersioningException( - String.format("Item %s: update version status failed, version %s is already in status %s", itemId, - version.getId(), status)); + String.format("Item %s: update version status failed, version %s is already in status %s", itemId, + version.getId(), status)); } version.setStatus(status); @@ -151,45 +149,43 @@ public class VersioningManagerImpl implements VersioningManager { private InternalVersion getVersion(String itemId, String versionId) { return versionDao.get(itemId, versionId) - .map(retrievedVersion -> getUpdateRetrievedVersion(itemId, retrievedVersion)) - .orElseGet(() -> getSyncedVersion(itemId, versionId)); + .map(retrievedVersion -> getUpdateRetrievedVersion(itemId, retrievedVersion)) + .orElseGet(() -> getSyncedVersion(itemId, versionId)); } private InternalVersion getUpdateRetrievedVersion(String itemId, InternalVersion version) { if (version.getStatus() == Certified - && version.getState().getSynchronizationState() == SynchronizationState.OutOfSync) { + && version.getState().getSynchronizationState() == SynchronizationState.OutOfSync) { forceSync(itemId, version.getId()); - //LOGGER.info("Item Id {}, version Id {}: Force sync is done", itemId, version.getId()); version = versionDao.get(itemId, version.getId()).orElseThrow(() -> new IllegalStateException( - "Get version after a successful force sync must return the version")); + "Get version after a successful force sync must return the version")); } return version; } private InternalVersion getSyncedVersion(String itemId, String versionId) { sync(itemId, versionId); - //LOGGER.info("Item Id {}, version Id {}: First time sync is done", itemId, version.getId()); return versionDao.get(itemId, versionId).orElseThrow( - () -> new IllegalStateException("Get version after a successful sync must return the version")); + () -> new IllegalStateException("Get version after a successful sync must return the version")); } private void validateBaseVersion(String itemId, Version baseVersion) { if (Certified != baseVersion.getStatus()) { throw new VersioningException( - String.format("Item %s: base version %s must be Certified", itemId, baseVersion.getId())); + String.format("Item %s: base version %s must be Certified", itemId, baseVersion.getId())); } } private void validateVersionName(String itemId, String versionName) { if (versionDao.list(itemId).stream().anyMatch(version -> versionName.equals(version.getName()))) { throw new VersioningException( - String.format("Item %s: create version failed, a version with the name %s already exist", itemId, - versionName)); + String.format("Item %s: create version failed, a version with the name %s already exist", itemId, + versionName)); } } private void updateStatusOnItem(String itemId, VersionStatus addedVersionStatus, - VersionStatus removedVersionStatus) { + VersionStatus removedVersionStatus) { InternalItem item = itemDao.get(itemId); if (item == null) { throw new VersioningException(String.format("Item with Id %s does not exist", itemId)); diff --git a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDaoTest.java b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDaoTest.java index b4fe655..c827aaa 100644 --- a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDaoTest.java +++ b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/ItemZusammenDaoTest.java @@ -41,19 +41,17 @@ import java.util.Map; import java.util.stream.Collectors; import java.util.stream.Stream; import org.junit.Assert; -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.mockito.ArgumentCaptor; import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; import org.onap.sdc.common.versioning.persistence.types.InternalItem; import org.onap.sdc.common.versioning.services.types.ItemStatus; import org.onap.sdc.common.versioning.services.types.VersionStatus; import org.onap.sdc.common.zusammen.services.ZusammenAdaptor; -@RunWith(MockitoJUnitRunner.class) public class ItemZusammenDaoTest { private static final String APP_PROP_1 = "app_prop1"; @@ -65,18 +63,18 @@ public class ItemZusammenDaoTest { SESSION_CONTEXT.setTenant("tenant"); } - @Mock - private ZusammenSessionContextCreator contextCreatorMock; - @Mock - private ZusammenAdaptor zusammenAdaptorMock; + private final ZusammenSessionContextCreator contextCreatorMock = Mockito.mock(ZusammenSessionContextCreator.class); + + private final ZusammenAdaptor zusammenAdaptorMock = Mockito.mock(ZusammenAdaptor.class); @InjectMocks private ItemZusammenDao itemDao; - @Before + @BeforeEach public void mockSessionContext() { + MockitoAnnotations.initMocks(this); doReturn(SESSION_CONTEXT).when(contextCreatorMock).create(); - } + } @Test public void testListWhenNone() { @@ -96,16 +94,15 @@ public class ItemZusammenDaoTest { vsp2versionStatuses.put(VersionStatus.Draft.name(), 3); vsp2versionStatuses.put(VersionStatus.Certified.name(), 2); - List returnedItems = - Stream.of(createItem("1", "vsp1", "vsp 1", "vsp", new Date(), new Date(), new HashMap<>()), - createItem("2", "vlm1", "vlm 1", "vlm", new Date(), new Date(), vlm1versionStatuses), - createItem("3", "vsp2", "vsp 2", "vsp", new Date(), new Date(), vsp2versionStatuses)) - .collect(Collectors.toList()); + Stream.of(createItem("1", "vsp1", "vsp 1", "vsp", new Date(), new Date(), new HashMap<>()), + createItem("2", "vlm1", "vlm 1", "vlm", new Date(), new Date(), vlm1versionStatuses), + createItem("3", "vsp2", "vsp 2", "vsp", new Date(), new Date(), vsp2versionStatuses)) + .collect(Collectors.toList()); doReturn(returnedItems).when(zusammenAdaptorMock).listItems(eq(SESSION_CONTEXT)); Collection items = itemDao.list(); - assertEquals(items.size(), 3); + assertEquals(3, items.size()); Iterator itemIterator = items.iterator(); assertItemEquals(itemIterator.next(), returnedItems.get(0)); @@ -129,15 +126,15 @@ public class ItemZusammenDaoTest { versionStatuses.put(VersionStatus.Certified.name(), 2); Item toBeReturned = - createItem("1", "vsp1", "vsp 1", "vsp", new Date(System.currentTimeMillis() - 100), new Date(), - versionStatuses); + createItem("1", "vsp1", "vsp 1", "vsp", new Date(System.currentTimeMillis() - 100), new Date(), + versionStatuses); doReturn(toBeReturned).when(zusammenAdaptorMock).getItem(eq(SESSION_CONTEXT), eq(new Id(itemId))); InternalItem item = itemDao.get(itemId); Assert.assertNotNull(item); assertItemEquals(item, toBeReturned); - assertEquals(item.getStatus(), ItemStatus.ACTIVE); + assertEquals(ItemStatus.ACTIVE, item.getStatus()); } @@ -152,7 +149,7 @@ public class ItemZusammenDaoTest { String itemId = "1"; doReturn(new Id(itemId)).when(zusammenAdaptorMock) - .createItem(eq(SESSION_CONTEXT), capturedZusammenInfo.capture()); + .createItem(eq(SESSION_CONTEXT), capturedZusammenInfo.capture()); InternalItem item = itemDao.create(inputItem); @@ -183,7 +180,7 @@ public class ItemZusammenDaoTest { ArgumentCaptor capturedZusammenInfo = ArgumentCaptor.forClass(Info.class); doReturn(new Id(itemId)).when(zusammenAdaptorMock) - .createItem(eq(SESSION_CONTEXT), eq(new Id(inputItem.getId())),capturedZusammenInfo.capture()); + .createItem(eq(SESSION_CONTEXT), eq(new Id(inputItem.getId())), capturedZusammenInfo.capture()); InternalItem item = itemDao.create(inputItem); @@ -216,7 +213,7 @@ public class ItemZusammenDaoTest { itemDao.update(item); verify(zusammenAdaptorMock) - .updateItem(eq(SESSION_CONTEXT), eq(new Id(item.getId())), capturedZusammenInfo.capture()); + .updateItem(eq(SESSION_CONTEXT), eq(new Id(item.getId())), capturedZusammenInfo.capture()); Info capturedInfo = capturedZusammenInfo.getValue(); assertEquals(capturedInfo.getName(), item.getName()); @@ -226,7 +223,7 @@ public class ItemZusammenDaoTest { } private Item createItem(String id, String name, String description, String type, Date creationTime, - Date modificationTime, Map versionStatusCounters) { + Date modificationTime, Map versionStatusCounters) { Item item = new Item(); item.setId(new Id(id)); Info info = new Info(); diff --git a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDaoTest.java b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDaoTest.java index ee6ca86..985e3c6 100644 --- a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDaoTest.java +++ b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/persistence/zusammen/VersionZusammenDaoTest.java @@ -40,19 +40,17 @@ import java.util.Optional; import java.util.stream.Collectors; import java.util.stream.Stream; import org.junit.Assert; -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.mockito.ArgumentCaptor; import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; import org.onap.sdc.common.versioning.persistence.types.InternalVersion; import org.onap.sdc.common.versioning.services.types.Revision; import org.onap.sdc.common.versioning.services.types.VersionStatus; import org.onap.sdc.common.zusammen.services.ZusammenAdaptor; -@RunWith(MockitoJUnitRunner.class) public class VersionZusammenDaoTest { private static final String STATUS_PROPERTY = "status"; @@ -63,16 +61,16 @@ public class VersionZusammenDaoTest { SESSION_CONTEXT.setTenant("tenant"); } - @Mock - private ZusammenSessionContextCreator contextCreatorMock; - @Mock - private ZusammenAdaptor zusammenAdaptorMock; + private final ZusammenSessionContextCreator contextCreatorMock = Mockito.mock(ZusammenSessionContextCreator.class); + private final ZusammenAdaptor zusammenAdaptorMock = Mockito.mock(ZusammenAdaptor.class); @InjectMocks private VersionZusammenDao versionDao; - @Before + @BeforeEach public void mockSessionContext() { + MockitoAnnotations.initMocks(this); doReturn(SESSION_CONTEXT).when(contextCreatorMock).create(); + } @Test @@ -103,7 +101,7 @@ public class VersionZusammenDaoTest { .listPublicVersions(eq(SESSION_CONTEXT), eq(new Id(itemId))); List versions = versionDao.list(itemId); - Assert.assertEquals(versions.size(), 3); + Assert.assertEquals(3, versions.size()); int zusammenVersionIndex; for (InternalVersion version : versions) { @@ -373,7 +371,7 @@ public class VersionZusammenDaoTest { List revisions = versionDao.listRevisions(itemId, versionId); - Assert.assertEquals(revisions.size(), 4); + Assert.assertEquals(4, revisions.size()); assertRevisionEquals(revisions.get(0), zusammenRevisions.get(0)); // rev4 - latest assertRevisionEquals(revisions.get(1), zusammenRevisions.get(2)); // rev3 assertRevisionEquals(revisions.get(2), zusammenRevisions.get(3)); // rev2 diff --git a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImplTest.java b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImplTest.java index 8982496..b7f69a0 100644 --- a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImplTest.java +++ b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/MajorVersionCalculatorImplTest.java @@ -16,18 +16,19 @@ package org.onap.sdc.common.versioning.services.impl; -import org.junit.Before; -import org.junit.Test; -import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; - import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.onap.sdc.common.versioning.services.types.VersionCreationMethod; public class MajorVersionCalculatorImplTest { private MajorVersionCalculatorImpl calculator; private static final String INITIAL_VERSION = "1.0"; - @Before + @BeforeEach public void init() { calculator = new MajorVersionCalculatorImpl(); } @@ -35,7 +36,7 @@ public class MajorVersionCalculatorImplTest { @Test public void calculateInitialVersionWithNullAndMajor() { String expectedInitialVersion = calculator.calculate(null, VersionCreationMethod.major); - assertEquals(expectedInitialVersion, INITIAL_VERSION); + assertEquals(INITIAL_VERSION, expectedInitialVersion); } @Test @@ -91,10 +92,13 @@ public class MajorVersionCalculatorImplTest { assertEquals(expectedValue, actualValue); } - @Test(expected = IllegalArgumentException.class) + @Test public void calculateException() { String initialValue = "1"; - calculator.calculate(initialValue, VersionCreationMethod.minor); + assertThrows( + IllegalArgumentException.class, + () -> calculator.calculate(initialValue, VersionCreationMethod.minor) + ); } } \ No newline at end of file diff --git a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImplTest.java b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImplTest.java index 29b8220..7059684 100644 --- a/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImplTest.java +++ b/versioning-lib/src/test/java/org/onap/sdc/common/versioning/services/impl/VersioningManagerImplTest.java @@ -19,34 +19,34 @@ package org.onap.sdc.common.versioning.services.impl; 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.assertThrows; import static org.mockito.Mockito.when; import com.google.common.collect.ImmutableList; import java.util.List; import java.util.Optional; -import org.junit.Test; -import org.junit.runner.RunWith; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.mockito.InjectMocks; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; -import org.onap.sdc.common.versioning.persistence.ItemDao; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; import org.onap.sdc.common.versioning.persistence.VersionDao; import org.onap.sdc.common.versioning.persistence.types.InternalVersion; -import org.onap.sdc.common.versioning.services.VersioningManager; import org.onap.sdc.common.versioning.services.types.Version; -@RunWith(MockitoJUnitRunner.class) public class VersioningManagerImplTest { - @Mock - private ItemDao itemDao; - @Mock - private VersionDao versionDao; - @Mock - private VersionCalculator versionCalculator; + private final VersionDao versionDao = Mockito.mock(VersionDao.class); + + private final VersionCalculator versionCalculator = Mockito.mock(VersionCalculator.class); @InjectMocks private VersioningManagerImpl versioningManager; + @BeforeEach + public void mockSessionContext() { + MockitoAnnotations.initMocks(this); + } + @Test public void testList() { String blaBla = "blaBla"; @@ -70,11 +70,14 @@ public class VersioningManagerImplTest { assertEquals(blaBla, version.getId()); } - @Test(expected = IllegalStateException.class) + @Test public void testGetVersionEmpty() { String blaBla = "blaBla"; when(versionDao.get(blaBla, blaBla)).thenReturn(Optional.empty()); - Version version = versioningManager.get(blaBla, blaBla); + assertThrows( + IllegalStateException.class, + () -> versioningManager.get(blaBla, blaBla) + ); } @Test diff --git a/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/config/ZusammenConfigTest.java b/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/config/ZusammenConfigTest.java index 007ad69..ce240a6 100644 --- a/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/config/ZusammenConfigTest.java +++ b/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/config/ZusammenConfigTest.java @@ -16,9 +16,9 @@ package org.onap.sdc.common.zusammen.config; -import org.junit.After; import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; import org.mockito.Mockito; public class ZusammenConfigTest { @@ -35,7 +35,7 @@ public class ZusammenConfigTest { Assert.assertEquals(a, System.getProperty("cassandra.nodes")); } - @After + @AfterEach public void cleanUp() { System.setProperty("cassandra.nodes", emptyStr); System.setProperty("cassandra.port", emptyStr); diff --git a/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/persistence/ZusammenConnectorTest.java b/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/persistence/ZusammenConnectorTest.java index b65cdc9..3ebcaba 100644 --- a/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/persistence/ZusammenConnectorTest.java +++ b/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/persistence/ZusammenConnectorTest.java @@ -19,7 +19,7 @@ package org.onap.sdc.common.zusammen.persistence; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.assertThrows; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; @@ -52,33 +52,29 @@ import com.amdocs.zusammen.datatypes.response.ReturnCode; import com.google.common.collect.ImmutableList; import java.util.Collection; import java.util.List; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.Mock; -import org.mockito.junit.MockitoJUnitRunner; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; import org.onap.sdc.common.zusammen.persistence.impl.ZusammenConnectorImpl; -@RunWith(MockitoJUnitRunner.class) public class ZusammenConnectorTest { - @Mock - private ItemAdaptorFactory itemAdaptorFactoryMock; - @Mock - private ItemVersionAdaptorFactory versionAdaptorFactoryMock; - @Mock - private ElementAdaptorFactory elementAdaptorFactoryMock; - @Mock - private HealthAdaptorFactory healthAdaptorFactoryMock; + private final ItemAdaptorFactory itemAdaptorFactoryMock = Mockito.mock(ItemAdaptorFactory.class); + + private final ItemVersionAdaptorFactory versionAdaptorFactoryMock = Mockito.mock(ItemVersionAdaptorFactory.class); + + private final ElementAdaptorFactory elementAdaptorFactoryMock = Mockito.mock(ElementAdaptorFactory.class); + + private final HealthAdaptorFactory healthAdaptorFactoryMock = Mockito.mock(HealthAdaptorFactory.class); private ZusammenConnector zusammenConnector; - @Mock - private SessionContext sessionContext; - @Before + private final SessionContext sessionContext = Mockito.mock(SessionContext.class); + + @BeforeEach public void init() { zusammenConnector = - new ZusammenConnectorImpl(itemAdaptorFactoryMock, versionAdaptorFactoryMock, elementAdaptorFactoryMock, - healthAdaptorFactoryMock); + new ZusammenConnectorImpl(itemAdaptorFactoryMock, versionAdaptorFactoryMock, elementAdaptorFactoryMock, + healthAdaptorFactoryMock); } @@ -115,7 +111,7 @@ public class ZusammenConnectorTest { assertEquals(items.size(), itemList.size()); } - @Test(expected = org.onap.sdc.common.zusammen.services.exceptions.ZusammenException.class) + @Test public void checkListItemFailure() { ItemAdaptor itemAdaptor = mock(ItemAdaptor.class); when(itemAdaptorFactoryMock.createInterface(sessionContext)).thenReturn(itemAdaptor); @@ -123,8 +119,10 @@ public class ZusammenConnectorTest { Response> response = new Response<>(items); setResponseErrorReturnCode(response); when(itemAdaptor.list(sessionContext)).thenReturn(response); - zusammenConnector.listItems(sessionContext); - fail("Should never get here"); + assertThrows( + org.onap.sdc.common.zusammen.services.exceptions.ZusammenException.class, + () -> zusammenConnector.listItems(sessionContext) + ); } @Test @@ -140,7 +138,7 @@ public class ZusammenConnectorTest { assertEquals(idStr, retId.getValue()); } - @Test(expected = org.onap.sdc.common.zusammen.services.exceptions.ZusammenException.class) + @Test public void testCreateItemFailure() { ItemAdaptor itemAdaptor = mock(ItemAdaptor.class); when(itemAdaptorFactoryMock.createInterface(sessionContext)).thenReturn(itemAdaptor); @@ -150,11 +148,12 @@ public class ZusammenConnectorTest { setResponseErrorReturnCode(response); Info info = new Info(); when(itemAdaptor.create(sessionContext, info)).thenReturn(response); - zusammenConnector.createItem(sessionContext, info); - + assertThrows( + org.onap.sdc.common.zusammen.services.exceptions.ZusammenException.class, + () -> zusammenConnector.createItem(sessionContext, info) + ); } - @Test public void testDeleteItem() { ItemAdaptor itemAdaptor = mock(ItemAdaptor.class); @@ -284,7 +283,6 @@ public class ZusammenConnectorTest { Response response = new Response<>(null); response.setValue(itemVersion); when(itemAdaptor.get(sessionContext, Space.PRIVATE, id, id)).thenReturn(response); - ItemVersion version = zusammenConnector.getVersion(sessionContext, id, id); assertEquals(id.getValue(), itemVersion.getId().getValue()); } diff --git a/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/services/impl/ZusammenAdaptorImplTest.java b/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/services/impl/ZusammenAdaptorImplTest.java index 3ac4e26..4fc4b97 100644 --- a/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/services/impl/ZusammenAdaptorImplTest.java +++ b/zusammen-lib/src/test/java/org/onap/sdc/common/zusammen/services/impl/ZusammenAdaptorImplTest.java @@ -21,6 +21,7 @@ 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.assertThrows; import static org.mockito.ArgumentMatchers.eq; import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.verify; @@ -37,12 +38,12 @@ import java.util.Arrays; import java.util.Collection; import java.util.List; import java.util.Optional; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.mockito.ArgumentCaptor; import org.mockito.Captor; import org.mockito.InjectMocks; -import org.mockito.Mock; +import org.mockito.Mockito; import org.mockito.MockitoAnnotations; import org.onap.sdc.common.zusammen.persistence.ZusammenConnector; @@ -52,17 +53,16 @@ public class ZusammenAdaptorImplTest { private static final ElementContext ELEMENT_CONTEXT = new ElementContext(); private static final Id ELEMENT_ID = new Id("elementId 0"); private static final List ELEMENTS = - Arrays.asList(createElementInfo("elementId1", "element1"), createElementInfo("elementId2", "element2"), - createElementInfo("elementId3", "element3")); + Arrays.asList(createElementInfo("elementId1", "element1"), createElementInfo("elementId2", "element2"), + createElementInfo("elementId3", "element3")); - @Mock - private ZusammenConnector connector; + private final ZusammenConnector connector = Mockito.mock(ZusammenConnector.class); @InjectMocks private ZusammenAdaptorImpl zusammenAdaptor; @Captor private ArgumentCaptor savedElementArg; - @Before + @BeforeEach public void setUp() { MockitoAnnotations.initMocks(this); } @@ -72,7 +72,7 @@ public class ZusammenAdaptorImplTest { doReturn(ELEMENTS).when(connector).listElements(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID); Optional element = - zusammenAdaptor.getElementByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "nonExistingName"); + zusammenAdaptor.getElementByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "nonExistingName"); assertFalse(element.isPresent()); } @@ -82,7 +82,7 @@ public class ZusammenAdaptorImplTest { doReturn(ELEMENTS).when(connector).listElements(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID); Optional elementInfo = - zusammenAdaptor.getElementInfoByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "nonExistingName"); + zusammenAdaptor.getElementInfoByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "nonExistingName"); assertFalse(elementInfo.isPresent()); } @@ -104,7 +104,7 @@ public class ZusammenAdaptorImplTest { doReturn(ELEMENTS).when(connector).listElements(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID); Optional elementInfo = - zusammenAdaptor.getElementInfoByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "element2"); + zusammenAdaptor.getElementInfoByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "element2"); assertTrue(elementInfo.isPresent()); assertEquals(ELEMENTS.get(1), elementInfo.get()); @@ -116,7 +116,7 @@ public class ZusammenAdaptorImplTest { doReturn(ELEMENTS).when(connector).listElements(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID); List returnedElements = - Arrays.asList(new ZusammenElement(), new ZusammenElement(), new ZusammenElement()); + Arrays.asList(new ZusammenElement(), new ZusammenElement(), new ZusammenElement()); doReturn(returnedElements.get(0)).when(connector).getElement(CONTEXT, ELEMENT_CONTEXT, ELEMENTS.get(0).getId()); doReturn(returnedElements.get(1)).when(connector).getElement(CONTEXT, ELEMENT_CONTEXT, ELEMENTS.get(1).getId()); doReturn(returnedElements.get(2)).when(connector).getElement(CONTEXT, ELEMENT_CONTEXT, ELEMENTS.get(2).getId()); @@ -131,7 +131,7 @@ public class ZusammenAdaptorImplTest { doReturn(ELEMENTS).when(connector).listElements(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID); Collection elements = - zusammenAdaptor.listElementsByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "nonExistingName"); + zusammenAdaptor.listElementsByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "nonExistingName"); assertTrue(elements.isEmpty()); } @@ -144,14 +144,17 @@ public class ZusammenAdaptorImplTest { doReturn(returnedElements).when(connector).listElements(CONTEXT, ELEMENT_CONTEXT, ELEMENTS.get(1).getId()); Collection elements = - zusammenAdaptor.listElementsByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "element2"); + zusammenAdaptor.listElementsByName(CONTEXT, ELEMENT_CONTEXT, ELEMENT_ID, "element2"); assertEquals(returnedElements, elements); } - @Test(expected = IllegalArgumentException.class) + @Test public void failWhenSavingElementWithoutIdNameOrAction() { - zusammenAdaptor.saveElement(CONTEXT, ELEMENT_CONTEXT, new ZusammenElement(), "Illegal element save"); + assertThrows( + IllegalArgumentException.class, + () -> zusammenAdaptor.saveElement(CONTEXT, ELEMENT_CONTEXT, new ZusammenElement(), "Illegal element save") + ); } @Test -- cgit 1.2.3-korg