package org.onap.so.cloud.authentication;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import java.nio.file.Files;
com.woorea.openstack.keystone.v3.model.Authentication actual =
authenticationMethodFactory.getAuthenticationForV3(identity, "project-x");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
}
package org.onap.so.openstack.utils;
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.get;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.junit.Assert.assertNotNull;
import java.io.IOException;
import java.util.ArrayList;
VduInstance actual = heatUtils.instantiateVdu(cloudInfo, instanceName, inputs, vduModel, rollbackOnFailure);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
-
@Test
public void queryVduTest() throws Exception {
VduInstance expected = new VduInstance();
VduInstance actual = heatUtils.queryVdu(cloudInfo, instanceId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
VduInstance actual = heatUtils.deleteVdu(cloudInfo, instanceId, timeoutInMinutes);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
assertNotNull(stackInfo);
}
-
-
}
package org.onap.so.openstack.utils;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
import java.io.File;
StackInfo actualStackInfo = heatUtils.updateStack(cloudSiteId, cloudOwner, tenantId, stackName, heatTemplate,
stackInputs, pollForCompletion, timeoutMinutes);
- assertThat(actualStackInfo, sameBeanAs(expectedStackInfo));
+ assertThat(actualStackInfo).usingRecursiveComparison().isEqualTo(expectedStackInfo);
}
@Test
StackInfo actualStackInfo = heatUtils.updateStack(cloudSiteId, cloudOwner, tenantId, stackName, heatTemplate,
stackInputs, pollForCompletion, timeoutMinutes, environmentString);
- assertThat(actualStackInfo, sameBeanAs(expectedStackInfo));
+ assertThat(actualStackInfo).usingRecursiveComparison().isEqualTo(expectedStackInfo);
}
@Test
StackInfo actualStackInfo = heatUtils.updateStack(cloudSiteId, cloudOwner, tenantId, stackName, heatTemplate,
stackInputs, pollForCompletion, timeoutMinutes, environmentString, files);
- assertThat(actualStackInfo, sameBeanAs(expectedStackInfo));
+ assertThat(actualStackInfo).usingRecursiveComparison().isEqualTo(expectedStackInfo);
}
}
package org.onap.so.openstack.utils;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNull;
import java.io.File;
import java.io.IOException;
Set<MsoHeatEnvironmentParameter> heatEnvironmentSet = yaml.getParameterListFromEnvt();
for (MsoHeatEnvironmentParameter heatEnvironment : heatEnvironmentSet) {
- assertThat(heatEnvironment, sameBeanAs(expectedHeatParam));
+ assertThat(heatEnvironment).usingRecursiveComparison().isEqualTo(expectedHeatParam);
}
}
Set<MsoHeatEnvironmentResource> heatResourceSet = yaml.getResourceListFromEnvt();
for (MsoHeatEnvironmentResource heatResource : heatResourceSet) {
- assertThat(heatResource, sameBeanAs(expectedHeatResource));
+ assertThat(heatResource).usingRecursiveComparison().isEqualTo(expectedHeatResource);
}
}
Set<HeatTemplateParam> heatParamSet = yaml.getParameterList();
for (HeatTemplateParam heatParam : heatParamSet) {
- assertThat(heatParam, sameBeanAs(expectedHeatParam));
+ assertThat(heatParam).usingRecursiveComparison().isEqualTo(expectedHeatParam);
}
}
}
package org.onap.so.adapters.catalogdb.catalogrest;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import javax.transaction.Transactional;
import javax.ws.rs.core.MediaType;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.util.UriComponentsBuilder;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
public class CloudConfigTest extends CatalogDbAdapterBaseTest {
restTemplate.exchange(builder.toUriString(), HttpMethod.GET, entity, String.class);
System.out.println(cloudSiteString.getBody());
assertEquals(Response.Status.OK.getStatusCode(), actualCloudSite.getStatusCode().value());
- assertThat(actualCloudSite.getBody(), sameBeanAs(cloudSite).ignoring("created").ignoring("updated")
- .ignoring("identityService.created").ignoring("identityService.updated"));
+ assertThat(actualCloudSite.getBody()).usingRecursiveComparison()
+ .ignoringFields("created", "updated", "identityService.created", "identityService.updated")
+ .isEqualTo(cloudSite);
}
-
-
}
package org.onap.so.adapters.catalogdb.catalogrest;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
@Test
public void service_map_test() throws JsonParseException, JsonMappingException, IOException {
Service actual = serviceMapper.mapService(getTestService(), 2);
- assertThat(actual, sameBeanAs(getExpectedService()));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(getExpectedService());
}
private Service getExpectedService() throws JsonParseException, JsonMappingException, IOException {
return mapper.readValue(getJson("ExpectedService.json"), Service.class);
}
-
private org.onap.so.db.catalog.beans.Service getTestService() {
org.onap.so.db.catalog.beans.Service testService = new org.onap.so.db.catalog.beans.Service();
testService.setCategory("category");
package org.onap.so.adapters.cloudregion;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.onap.so.db.catalog.client.CatalogDbClient;
import org.onap.so.db.catalog.data.repository.NetworkTechnologyReferenceRepository;
-
@RunWith(MockitoJUnitRunner.class)
public class CloudRegionRestImplTest {
@Test
public void mapCloudRegionTest() {
CloudRegion mappedRegion = cloudRestImpl.mapCloudRegion(cloudSite);
- assertThat(mappedRegion, sameBeanAs(testCloudRegion));
+ assertThat(mappedRegion).usingRecursiveComparison().isEqualTo(testCloudRegion);
}
-
@Test
public void mapCloudRegionVersionGreaterThan3Test() {
CloudSite cloudSite2 = new CloudSite();
testRegion2.setOwnerDefinedType("cLCP");
testRegion2.setCloudType("openstack");
testRegion2.setCloudZone("region");
- assertThat(mappedRegion, sameBeanAs(testRegion2));
+ assertThat(mappedRegion).usingRecursiveComparison().isEqualTo(testRegion2);
}
@Test
verify(catalogDbClientMock, times(1)).postCloudSite(cloudSite);
verify(aaiResClientMock, times(1)).createIfNotExists(Mockito.eq(uri), Mockito.any());
verify(aaiResClientMock, times(1)).createIfNotExists(actualURI.capture(), actualCloudRegion.capture());
- assertThat((CloudRegion) actualCloudRegion.getValue().get(), sameBeanAs(testCloudRegion));
+ assertThat((CloudRegion) actualCloudRegion.getValue().get()).usingRecursiveComparison()
+ .isEqualTo(testCloudRegion);
}
@Test
*/
package org.onap.so.heatbridge;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
private HeatBridgeImpl heatbridge = new HeatBridgeImpl(resourcesClient, cloudIdentity, CLOUD_OWNER, REGION_ID,
REGION_ID, TENANT_ID, NodeType.GREENFIELD);
-
@Before
public void setUp() {
when(resourcesClient.beginSingleTransaction()).thenReturn(transaction);
}
-
-
@Test
public void testExtractStackResourceIdsByResourceType() {
// Arrange
assertEquals(expectedServerIds, serverIds);
}
-
@Test
@Ignore
public void testUpdateVserversToAai() throws HeatBridgeException, JsonProcessingException {
when(server2.getFlavor()).thenReturn(flavor);
when(flavor.getId()).thenReturn("test-flavor-id");
-
// Act
heatbridge.buildAddVserversToAaiAction("test-genericVnf-id", "test-vfModule-id", servers);
assertEquals(2, relList3.getRelationship().size());
}
-
@Test
public void testUpdateImagesToAai() throws HeatBridgeException {
// Arrange
assertTrue(argument.getValue().isPresent());
- assertThat((L3InterfaceIpv6AddressList) argument.getValue().get(), sameBeanAs(ipv6));
+ assertThat((L3InterfaceIpv6AddressList) argument.getValue().get()).usingRecursiveComparison().isEqualTo(ipv6);
}
@Test
List<Image> images = heatbridge.extractOpenstackImagesFromServers(serverList);
-
// Assert
assertEquals(1, images.size());
}
return stackResources;
}
-
private String readTestResourceFile(String filePath) {
String content = null;
String pathname = Objects.requireNonNull(getClass().getClassLoader().getResource(filePath)).getFile();
return new String(Files.readAllBytes(Paths.get("src/test/resources/__files/" + filename)));
}
-
-
}
package org.onap.so.adapters.requestsdb;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.sql.Timestamp;
for (InfraActiveRequests result : responseList) {
if (result.getRequestId().equals(request.getRequestId())) {
- assertThat(request, sameBeanAs(result).ignoring("modifyTime"));
+ assertThat(request).usingRecursiveComparison().ignoringFields("modifyTime", "startTime")
+ .isEqualTo(result);
expectedReturned = true;
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.adapters.requestsdb.adapters;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.util.ArrayList;
fail("Null infraRequest");
// Then
- assertThat(infraRequest, sameBeanAs(testRequest).ignoring("requestBody").ignoring("endTime")
- .ignoring("startTime").ignoring("modifyTime"));
+ assertThat(infraRequest).usingRecursiveComparison()
+ .ignoringFields("requestBody", "endTime", "startTime", "modifyTime").isEqualTo(testRequest);
}
serviceInstanceName, configurationId, configurationName, vfModuleName);
InfraActiveRequests infraRequest = dbAdapter.getInfraRequest(requestId);
// Then
- assertThat(infraRequest, sameBeanAs(testRequest).ignoring("requestBody").ignoring("endTime")
- .ignoring("startTime").ignoring("modifyTime"));
+ assertThat(infraRequest).usingRecursiveComparison()
+ .ignoringFields("requestBody", "endTime", "startTime", "modifyTime").isEqualTo(testRequest);
}
null, null, null, null, null, null, null, null, null, null, null);
InfraActiveRequests infraRequest = dbAdapter.getInfraRequest(requestId);
// Then
- assertThat(infraRequest, sameBeanAs(testRequest).ignoring("requestBody").ignoring("endTime")
- .ignoring("startTime").ignoring("modifyTime"));
+ assertThat(infraRequest).usingRecursiveComparison()
+ .ignoringFields("requestBody", "endTime", "startTime", "modifyTime").isEqualTo(testRequest);
}
@Test
dbAdapter.setInstanceNfvoMappingRepository(instanceId, nfvoName, endpoint, username, password, apiRoot);
InstanceNfvoMapping dbInstNfvoMap = dbAdapter.getInstanceNfvoMapping(instanceId);
- assertThat(dbInstNfvoMap, sameBeanAs(instanceNfvoMapping));
+ assertThat(dbInstNfvoMap).usingRecursiveComparison().isEqualTo(instanceNfvoMapping);
}
dbAdapter.updateServiceOperationStatus(serviceId, operationId, operation, userId, result, operationContent,
progress, reason);
OperationStatus dbOpStatus = operationStatusRepository.findOneByServiceIdAndOperationId(serviceId, operationId);
- assertThat(dbOpStatus, sameBeanAs(updatedOperationStatus).ignoring("operateAt").ignoring("finishedAt"));
+ assertThat(dbOpStatus).usingRecursiveComparison().ignoringFields("operateAt", "finishedAt")
+ .isEqualTo(updatedOperationStatus);
}
dbAdapter.updateServiceOperationStatus(serviceId, operationId, operation, userId, result, operationContent,
progress, reason);
OperationStatus dbOpStatus = operationStatusRepository.findOneByServiceIdAndOperationId(serviceId, operationId);
- assertThat(dbOpStatus, sameBeanAs(updatedOperationStatus).ignoring("operateAt").ignoring("finishedAt"));
+ assertThat(dbOpStatus).usingRecursiveComparison().ignoringFields("operateAt", "finishedAt")
+ .isEqualTo(updatedOperationStatus);
}
@Test
dbAdapter.initResourceOperationStatus(serviceId, operationId, operationType, resourceTemplateUUIDs);
List<ResourceOperationStatus> testList =
resourceOperationStatusRepo.findByServiceIdAndOperationId(serviceId, operationId);
- assertThat(testList, sameBeanAs(expectedResult));
+ assertThat(testList).usingRecursiveComparison().isEqualTo(expectedResult);
}
@Test
ResourceOperationStatus actualResource =
dbAdapter.getResourceOperationStatus(serviceId, operationId, "template1");
- assertThat(actualResource, sameBeanAs(resource1));
+ assertThat(actualResource).usingRecursiveComparison().isEqualTo(resource1);
}
@Test
ResourceOperationStatus actualResource =
dbAdapter.getResourceOperationStatus(serviceId, operationId, "template1");
- assertThat(actualResource, sameBeanAs(expectedResource));
+ assertThat(actualResource).usingRecursiveComparison().isEqualTo(expectedResource);
}
}
package org.onap.so.adapters.requestsdb.client;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
}
private void verifyOperationStatus(OperationStatus request, OperationStatus response) {
- assertThat(request, sameBeanAs(response).ignoring("operateAt").ignoring("finishedAt"));
+ assertThat(request).usingRecursiveComparison().ignoringFields("operateAt", "finishedAt").isEqualTo(response);
}
private void verifyInfraActiveRequests(InfraActiveRequests infraActiveRequestsResponse) {
- assertThat(infraActiveRequestsResponse, sameBeanAs(infraActiveRequests).ignoring("modifyTime").ignoring("log")
- .ignoring("cloudApiRequests.created").ignoring("cloudApiRequests.id"));
+ assertThat(infraActiveRequestsResponse).usingRecursiveComparison()
+ .ignoringFields("modifyTime", "startTime", "log", "cloudApiRequests").isEqualTo(infraActiveRequests);
}
@Test
requestsDbClient.save(request);
List<InfraActiveRequests> infraActiveRequests = requestsDbClient.getInProgressVolumeGroupsAndVfModules();
- assertThat(request, sameBeanAs(infraActiveRequests.get(0)).ignoring("modifyTime"));
+ assertThat(request).usingRecursiveComparison().ignoringFields("modifyTime", "startTime")
+ .isEqualTo(infraActiveRequests.get(0));
}
@Test
assertEquals("assign", requestProcessingData.get(0).getValue());
}
}
-
package org.onap.so.adapters.sdnc.impl;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.onap.so.adapters.sdnc.SDNCAdapterApplication;
RequestTunables mappedTunable = tunableMapper.setTunables(testMapper);
- assertThat(mappedTunable, sameBeanAs(expectedResult));
+ assertThat(mappedTunable).usingRecursiveComparison().isEqualTo(expectedResult);
}
@Test
RequestTunables mappedTunable = tunableMapper.setTunables(testMapper);
- assertThat(mappedTunable, sameBeanAs(expectedResult));
+ assertThat(mappedTunable).usingRecursiveComparison().isEqualTo(expectedResult);
}
@Test
RequestTunables mappedTunable = tunableMapper.setTunables(testMapper);
- assertThat(mappedTunable, sameBeanAs(expectedResult));
+ assertThat(mappedTunable).usingRecursiveComparison().isEqualTo(expectedResult);
}
@Test
RequestTunables mappedTunable = tunableMapper.setTunables(testMapper);
- assertThat(mappedTunable, sameBeanAs(expectedResult));
+ assertThat(mappedTunable).usingRecursiveComparison().isEqualTo(expectedResult);
}
-
@Test
public void test_setTunables_EmptyOperation_EmptyMSOActionRESTDELETE() {
RequestTunables expectedResult = new RequestTunables("testReqId", "", "", "restdelete");
RequestTunables mappedTunable = tunableMapper.setTunables(testMapper);
- assertThat(mappedTunable, sameBeanAs(expectedResult));
+ assertThat(mappedTunable).usingRecursiveComparison().isEqualTo(expectedResult);
}
}
*/
package org.onap.so.asdc.activity;
+import static org.assertj.core.api.Assertions.assertThat;
import java.nio.file.Files;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
ActivitySpec activitySpec = deployActivitySpecs.mapActivitySpecFromCatalogToSdc(catalogActivitySpec);
ActivitySpec expected = mapper.readValue(
new String(Files.readAllBytes(Paths.get("src/test/resources/ActivitySpec.json"))), ActivitySpec.class);
- assertThat(expected, sameBeanAs(activitySpec));
+ assertThat(expected).usingRecursiveComparison().isEqualTo(activitySpec);
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.asdc.client.exceptions;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
public class ASDCControllerExceptionTest {
@Test
public void asdcParametersExceptionTest() {
ASDCControllerException asdcDownloadException = new ASDCControllerException(exceptionMessage);
-
- Exception expectedException = new Exception(exceptionMessage);
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
}
@Test
public void asdcParametersExceptionThrowableTest() {
Throwable throwableCause = new Throwable(throwableMessage);
ASDCControllerException asdcDownloadException = new ASDCControllerException(exceptionMessage, throwableCause);
-
- Exception expectedException = new Exception(exceptionMessage, new Throwable(throwableMessage));
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
+ assertThat(asdcDownloadException).hasCause(throwableCause);
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.asdc.client.exceptions;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
public class ASDCDownloadExceptionTest {
@Test
public void asdcDownloadExceptionTest() {
ASDCDownloadException asdcDownloadException = new ASDCDownloadException(exceptionMessage);
-
- Exception expectedException = new Exception(exceptionMessage);
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
}
@Test
public void asdcDownloadExceptionThrowableTest() {
Throwable throwableCause = new Throwable(throwableMessage);
ASDCDownloadException asdcDownloadException = new ASDCDownloadException(exceptionMessage, throwableCause);
-
- Exception expectedException = new Exception(exceptionMessage, new Throwable(throwableMessage));
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
+ assertThat(asdcDownloadException).hasCause(throwableCause);
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.asdc.client.exceptions;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
public class ASDCParametersExceptionTest {
@Test
public void asdcParametersExceptionTest() {
ASDCParametersException asdcDownloadException = new ASDCParametersException(exceptionMessage);
-
- Exception expectedException = new Exception(exceptionMessage);
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
}
@Test
public void asdcParametersExceptionThrowableTest() {
Throwable throwableCause = new Throwable(throwableMessage);
ASDCParametersException asdcDownloadException = new ASDCParametersException(exceptionMessage, throwableCause);
-
- Exception expectedException = new Exception(exceptionMessage, new Throwable(throwableMessage));
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
+ assertThat(asdcDownloadException).hasCause(throwableCause);
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.asdc.client.exceptions;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Test;
public class ArtifactInstallerExceptionTest {
@Test
public void asdcParametersExceptionTest() {
ArtifactInstallerException asdcDownloadException = new ArtifactInstallerException(exceptionMessage);
-
- Exception expectedException = new Exception(exceptionMessage);
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
}
@Test
Throwable throwableCause = new Throwable(throwableMessage);
ArtifactInstallerException asdcDownloadException =
new ArtifactInstallerException(exceptionMessage, throwableCause);
-
- Exception expectedException = new Exception(exceptionMessage, new Throwable(throwableMessage));
-
- assertThat(asdcDownloadException, sameBeanAs(expectedException));
+ assertThat(asdcDownloadException).hasMessage(exceptionMessage);
+ assertThat(asdcDownloadException).hasCause(throwableCause);
}
}
package org.onap.so.asdc.client.test.rest;
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.post;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathMatching;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
@LocalServerPort
private int port;
-
@Rule
public TemporaryFolder folder = new TemporaryFolder();
-
@Before
public void setUp() {
// ASDC Controller writes to this path
arCustomization.setAllottedResource(expectedService);
-
expectedService.setAllotedResourceCustomization(arCustomizationSet);
AllottedResource actualResponse = allottedRepo.findResourceByModelUUID("5b18c75e-2d08-4bf2-ad58-4ea704ec648d");
-
if (actualResponse == null)
throw new Exception("No Allotted Resource Written to database");
-
- assertThat(actualResponse, sameBeanAs(expectedService).ignoring("0x1.created")
- .ignoring("0x1.allotedResourceCustomization.created"));
+ assertThat(actualResponse).usingRecursiveComparison().ignoringFieldsMatchingRegexes(".*created")
+ .isEqualTo(expectedService);
}
@Test
expectedService.setModelUUID("e16e4ed9-3429-423a-bc3c-1389ae91491c");
expectedService.setModelVersion("1.0");
-
-
Service actualService = serviceRepo.findOneByModelUUID("e16e4ed9-3429-423a-bc3c-1389ae91491c");
-
if (actualService == null)
throw new Exception("No Allotted Resource Written to database");
}
-
@Test
public void test_Vcpe_Infra_Distribution() throws Exception {
wireMockServer.stubFor(post(urlPathMatching("/aai/.*"))
assertEquals("ubuntu16test", service.get().getModelName());
}
-
@Test
public void testServiceBasicCnf() throws Exception {
wireMockServer.stubFor(post(urlPathMatching("/aai/.*"))
assertEquals("basic_network", service.get().getModelName());
}
-
protected String createURLWithPort(String uri) {
return "http://localhost:" + port + uri;
}
package org.onap.so.asdc.installer;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
toscaResourceStructure.setSuccessfulDeployment();
assertEquals("heatTemplateUUID", toscaResourceStructure.getHeatTemplateUUID());
- assertThat(toscaResourceStructure.getAllottedList(), sameBeanAs(new ArrayList<NodeTemplate>()));
+ assertThat(toscaResourceStructure.getAllottedList()).usingRecursiveComparison()
+ .isEqualTo(new ArrayList<NodeTemplate>());
assertEquals(sdcCsarHelper, toscaResourceStructure.getSdcCsarHelper());
- assertThat(toscaResourceStructure.getServiceMetadata(), sameBeanAs(new Metadata(new HashMap<>())));
- assertThat(toscaResourceStructure.getCatalogService(), sameBeanAs(new Service()));
- assertThat(toscaResourceStructure.getNetworkTypes(), sameBeanAs(new ArrayList<>()));
- assertThat(toscaResourceStructure.getVfTypes(), sameBeanAs(new ArrayList<>()));
- assertThat(toscaResourceStructure.getCatalogResourceCustomization(),
- sameBeanAs(new AllottedResourceCustomization()));
- assertThat(toscaResourceStructure.getCatalogNetworkResourceCustomization(),
- sameBeanAs(new NetworkResourceCustomization()));
- assertThat(toscaResourceStructure.getCatalogNetworkResource(), sameBeanAs(new NetworkResource()));
- assertThat(toscaResourceStructure.getCatalogVfModule(), sameBeanAs(new VfModule()));
- assertThat(toscaResourceStructure.getVnfResourceCustomization(), sameBeanAs(new VnfResourceCustomization()));
- assertThat(toscaResourceStructure.getVfModuleCustomization(), sameBeanAs(new VfModuleCustomization()));
- assertThat(toscaResourceStructure.getAllottedResource(), sameBeanAs(new AllottedResource()));
- assertThat(toscaResourceStructure.getAllottedResourceCustomization(),
- sameBeanAs(new AllottedResourceCustomization()));
- assertThat(toscaResourceStructure.getCatalogTempNetworkHeatTemplateLookup(),
- sameBeanAs(new TempNetworkHeatTemplateLookup()));
+ assertThat(toscaResourceStructure.getServiceMetadata()).usingRecursiveComparison()
+ .isEqualTo(new Metadata(new HashMap<>()));
+ assertThat(toscaResourceStructure.getCatalogService()).usingRecursiveComparison().isEqualTo(new Service());
+ assertThat(toscaResourceStructure.getNetworkTypes()).usingRecursiveComparison().isEqualTo(new ArrayList<>());
+ assertThat(toscaResourceStructure.getVfTypes()).usingRecursiveComparison().isEqualTo(new ArrayList<>());
+ assertThat(toscaResourceStructure.getCatalogResourceCustomization()).usingRecursiveComparison()
+ .isEqualTo(new AllottedResourceCustomization());
+ assertThat(toscaResourceStructure.getCatalogNetworkResourceCustomization()).usingRecursiveComparison()
+ .isEqualTo(new NetworkResourceCustomization());
+ assertThat(toscaResourceStructure.getCatalogNetworkResource()).usingRecursiveComparison()
+ .isEqualTo(new NetworkResource());
+ assertThat(toscaResourceStructure.getCatalogVfModule()).usingRecursiveComparison().isEqualTo(new VfModule());
+ assertThat(toscaResourceStructure.getVnfResourceCustomization()).usingRecursiveComparison()
+ .isEqualTo(new VnfResourceCustomization());
+ assertThat(toscaResourceStructure.getVfModuleCustomization()).usingRecursiveComparison()
+ .isEqualTo(new VfModuleCustomization());
+ assertThat(toscaResourceStructure.getAllottedResource()).usingRecursiveComparison()
+ .isEqualTo(new AllottedResource());
+ assertThat(toscaResourceStructure.getAllottedResourceCustomization()).usingRecursiveComparison()
+ .isEqualTo(new AllottedResourceCustomization());
+ assertThat(toscaResourceStructure.getCatalogTempNetworkHeatTemplateLookup()).usingRecursiveComparison()
+ .isEqualTo(new TempNetworkHeatTemplateLookup());
assertEquals("heatFilesUUID", toscaResourceStructure.getHeatFilesUUID());
assertEquals(artifactInfo, toscaResourceStructure.getToscaArtifact());
- assertThat(toscaResourceStructure.getToscaCsar(), sameBeanAs(new ToscaCsar()));
+ assertThat(toscaResourceStructure.getToscaCsar()).usingRecursiveComparison().isEqualTo(new ToscaCsar());
assertEquals("volHeatTemplateUUID", toscaResourceStructure.getVolHeatTemplateUUID());
assertEquals("envHeatTemplateUUID", toscaResourceStructure.getEnvHeatTemplateUUID());
assertEquals("serviceVersion", toscaResourceStructure.getServiceVersion());
assertEquals("workloadPerformance", toscaResourceStructure.getWorkloadPerformance());
- assertThat(toscaResourceStructure.getVfModule(), sameBeanAs(new VfModule()));
- assertThat(toscaResourceStructure.getTempNetworkHeatTemplateLookup(),
- sameBeanAs(new TempNetworkHeatTemplateLookup()));
+ assertThat(toscaResourceStructure.getVfModule()).usingRecursiveComparison().isEqualTo(new VfModule());
+ assertThat(toscaResourceStructure.getTempNetworkHeatTemplateLookup()).usingRecursiveComparison()
+ .isEqualTo(new TempNetworkHeatTemplateLookup());
assertEquals(true, toscaResourceStructure.isDeployedSuccessfully());
}
package org.onap.so.asdc.installer.heat;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
ToscaCsarRepository toscaCsarRepo = spy(ToscaCsarRepository.class);
-
doReturn(artifactUuid).when(toscaCsar).getArtifactUUID();
doReturn(checkSum).when(toscaCsar).getArtifactChecksum();
doReturn(returnValue).when(toscaCsarRepo).findById(artifactUuid);
verify(vfResourceStructure, times(3)).getResourceInstance();
verify(vfResourceStructure, times(5)).getNotification();
- assertThat(actualWatchdogComponentDistributionStatus,
- sameBeanAs(expectedComponentDistributionStatus).ignoring("createTime").ignoring("modifyTime"));
+ assertThat(actualWatchdogComponentDistributionStatus).usingRecursiveComparison()
+ .ignoringFields("createTime", "modifyTime").isEqualTo(expectedComponentDistributionStatus);
}
@Test
assertEquals(statusData.getDistributionID(), cdStatus.getDistributionId());
assertEquals(statusData.getComponentName(), cdStatus.getComponentName());
- assertThat(actualWatchdogComponentDistributionStatus,
- sameBeanAs(expectedWatchdogComponentDistributionStatus).ignoring("createTime").ignoring("modifyTime"));
+ assertThat(actualWatchdogComponentDistributionStatus).usingRecursiveComparison()
+ .ignoringFields("createTime", "modifyTime").isEqualTo(expectedWatchdogComponentDistributionStatus);
}
@Test
ToscaCsarRepository toscaCsarRepo = spy(ToscaCsarRepository.class);
-
ToscaCsar toscaCsar = mock(ToscaCsar.class);
Optional<ToscaCsar> returnValue = Optional.of(toscaCsar);
doReturn(artifactUuid).when(toscaCsar).getArtifactUUID();
doReturn(resourceCustomizationUUID).when(metadata).getValue(SdcPropertyNames.PROPERTY_NAME_CUSTOMIZATIONUUID);
doReturn(uuid).when(metadata).getValue(SdcPropertyNames.PROPERTY_NAME_VFMODULEMODELUUID);
-
// vnfc instance group list
List<Group> vnfcInstanceGroupList = new ArrayList<>();
Group vnfcG1 = mock(Group.class);
return toscaResourceStructObj;
}
-
-
@Test
public void installTheResourceExceptionTest() throws Exception {
expectedException.expect(ArtifactInstallerException.class);
doReturn(null).when(toscaInstaller).getLeafPropertyValue(entityDetails, SdcPropertyNames.PROPERTY_NAME_NFTYPE);
}
-
@Test
public void getConfigurationResourceCustomizationTest() {
prepareConfigurationResourceCustomization();
}
-
class MockConstants {
public final static String MODEL_NAME = "VLAN Network Receptor Configuration";
public final static String MODEL_INVARIANT_UUID = "1608eef4-de53-4334-a8d2-ba79cab4bde0";
public final static String TEMPLATE_TYPE = "org.openecomp.nodes.VLANNetworkReceptor";
public final static String TEMPLATE_NAME = "VLAN Network Receptor Configuration 0";
-
}
}
--- /dev/null
+<?xml version="1.0"?>
+<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+ xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.onap.so</groupId>
+ <artifactId>bpmn</artifactId>
+ <version>1.17.0-SNAPSHOT</version>
+ </parent>
+ <artifactId>MSOCommonBPMN</artifactId>
+ <name>MSOCommonBPMN</name>
+ <packaging>jar</packaging>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <compilerId>groovy-eclipse-compiler</compilerId>
+ </configuration>
+ <dependencies>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-eclipse-compiler</artifactId>
+ <version>3.6.0-03</version>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-eclipse-batch</artifactId>
+ <version>2.5.8-03</version>
+ </dependency>
+ </dependencies>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jar-plugin</artifactId>
+ <executions>
+ <execution>
+ <goals>
+ <goal>test-jar</goal>
+ </goals>
+ <configuration>
+ <skip>false</skip>
+ <excludes>
+ <exclude>**/validation/*</exclude>
+ </excludes>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.cxf</groupId>
+ <artifactId>cxf-codegen-plugin</artifactId>
+ <version>2.5.2</version>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>default-test</id>
+ <goals>
+ <goal>test</goal>
+ </goals>
+ <configuration>
+ <includes>
+ <include>**/AllTestSuites.java</include>
+ </includes>
+ </configuration>
+ </execution>
+ <execution>
+ <id>non-spring-tests</id>
+ <goals>
+ <goal>test</goal>
+ </goals>
+ <configuration>
+ <includes>
+ <include>**/NonSpringSuite.java</include>
+ </includes>
+ </configuration>
+ </execution>
+ <execution>
+ <id>groovy-tests</id>
+ <goals>
+ <goal>test</goal>
+ </goals>
+ <configuration>
+ <includes>
+ <include>**/AllGroovyTestSuites.java</include>
+ </includes>
+ </configuration>
+ </execution>
+ </executions>
+ <configuration>
+ <parallel>suites</parallel>
+ </configuration>
+ </plugin>
+ </plugins>
+ <pluginManagement>
+ <plugins>
+ <!--This plugin's configuration is used to store Eclipse m2e settings
+ only. It has no influence on the Maven build itself. -->
+ <plugin>
+ <groupId>org.eclipse.m2e</groupId>
+ <artifactId>lifecycle-mapping</artifactId>
+ <version>1.0.0</version>
+ <configuration>
+ <lifecycleMappingMetadata>
+ <pluginExecutions>
+ <pluginExecution>
+ <pluginExecutionFilter>
+ <groupId>
+ org.apache.maven.plugins
+ </groupId>
+ <artifactId>
+ maven-antrun-plugin
+ </artifactId>
+ <versionRange>
+ [1.3,)
+ </versionRange>
+ <goals>
+ <goal>execute</goal>
+ </goals>
+ </pluginExecutionFilter>
+ <action>
+ <execute>
+ <runOnIncremental>true</runOnIncremental>
+ </execute>
+ </action>
+ </pluginExecution>
+ </pluginExecutions>
+ </lifecycleMappingMetadata>
+ </configuration>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ </build>
+ <dependencies>
+ <dependency>
+ <groupId>org.camunda.bpm.springboot</groupId>
+ <artifactId>camunda-bpm-spring-boot-starter</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.cloud</groupId>
+ <artifactId>spring-cloud-contract-wiremock</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-test</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.junit.vintage</groupId>
+ <artifactId>junit-vintage-engine</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.camunda.bpm.extension.mockito</groupId>
+ <artifactId>camunda-bpm-mockito</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.camunda.connect</groupId>
+ <artifactId>camunda-connect-connectors-all</artifactId>
+ </dependency>
+ <dependency>
+ <!-- Needed for InMemoryH2Test -->
+ <groupId>com.h2database</groupId>
+ <artifactId>h2</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-xml</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-json</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-jsr223</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-test</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.so</groupId>
+ <artifactId>client-cds</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.so</groupId>
+ <artifactId>MSOCoreBPMN</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.so</groupId>
+ <artifactId>mso-catalog-db</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.so</groupId>
+ <artifactId>mso-requests-db</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.so.adapters</groupId>
+ <artifactId>mso-adapters-rest-interface</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>commons-lang</groupId>
+ <artifactId>commons-lang</artifactId>
+ <version>2.6</version>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.appc.client</groupId>
+ <artifactId>client-lib</artifactId>
+ <version>${appc.client.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-module-junit4</artifactId>
+ </exclusion>
+ <exclusion>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-api-mockito</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>org.onap.appc.client</groupId>
+ <artifactId>client-kit</artifactId>
+ <version>${appc.client.version}</version>
+ <exclusions>
+ <exclusion>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ </exclusion>
+ </exclusions>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jersey.core</groupId>
+ <artifactId>jersey-client</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jersey.inject</groupId>
+ <artifactId>jersey-hk2</artifactId>
+ <version>2.26</version>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jersey.media</groupId>
+ <artifactId>jersey-media-json-jackson</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>me.hdpe.bowman</groupId>
+ <artifactId>bowman-client</artifactId>
+ <version>${bowman.client.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>pl.pragmatists</groupId>
+ <artifactId>JUnitParams</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>ch.vorburger.mariaDB4j</groupId>
+ <artifactId>mariaDB4j</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-core</artifactId>
+ <version>3.16.0</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+</project>
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
- <version>3.11.1</version>
+ <version>3.16.0</version>
<scope>test</scope>
</dependency>
</dependencies>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.bpmn.common.scripts
-import static com.shazam.shazamcrest.MatcherAssert.assertThat
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs
+import static org.assertj.core.api.Assertions.assertThat
import static org.mockito.Mockito.spy
import static org.mockito.Mockito.times
import static org.mockito.Mockito.when
relationship.getRelationshipData().add(data)
relationshipList.getRelationship().add(relationship)
expectedVolumeGroup.setRelationshipList(relationshipList)
-
-
+
+
expectedVolumeGroup.setRelationshipList(relationshipList)
ConfirmVolumeGroupTenant confirmVolumeGroupTenant = spy(ConfirmVolumeGroupTenant.class)
when(confirmVolumeGroupTenant.getAAIClient()).thenReturn(client)
Mockito.verify(mockExecution, times(4)).setVariable(captor.capture(), captor.capture())
List<ExecutionEntity> executionEntities = captor.getAllValues()
- assertThat(executionEntities.get(3), sameBeanAs(expectedVolumeGroup))
+ assertThat(executionEntities.get(3)).usingRecursiveComparison().isEqualTo(expectedVolumeGroup)
}
}
-/*-
- * ============LICENSE_START=======================================================
- * ONAP - SO
- * ================================================================================
- * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
- * ================================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END=========================================================
- */
+/*-
+ * ============LICENSE_START=======================================================
+ * ONAP - SO
+ * ================================================================================
+ * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * ============LICENSE_END=========================================================
+ */
package org.onap.so.bpmn.common.scripts
import org.camunda.bpm.engine.impl.persistence.entity.ExecutionEntity
import static org.junit.Assert.*;
import org.junit.Test;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
class DecomposeServiceTest {
-
+
@Test
public void testDecomposeService() {
-
+
String catalogDbResponse = FileUtil.readResourceFile("__files/decomposition/catalogDbResponse.json");
-
+
ServiceDecomposition serviceDecomposition = new ServiceDecomposition();
ServiceInstance serviceInstance = new ServiceInstance();
serviceInstance.setInstanceId("serviceInstanceID");
serviceDecomposition.setServiceType("");
serviceDecomposition.setServiceRole("");
-
+
ArrayList networkResources = new ArrayList();
NetworkResource networkResource = new NetworkResource();
networkResource.setNetworkType("testNetworkType");
modelInfo.setModelCustomizationUuid("testModelCustomizationUuid");
modelInfo.setModelInstanceName("testModelInstanceName");
networkResource.setModelInfo(modelInfo);
-
+
networkResources.add(networkResource);
serviceDecomposition.setNetworkResources(networkResources)
serviceDecomposition.setServiceInstance(serviceInstance);
-
+
ServiceDecomposition serviceDecompositionExtracted = DecomposeJsonUtil.jsonToServiceDecomposition(catalogDbResponse, "serviceInstanceID")
-
- assertThat(serviceDecompositionExtracted, sameBeanAs(serviceDecomposition).ignoring("modelInfo").ignoring("vnfResources").ignoring("allottedResources").ignoring("networkResources.resourceId"));
+
+ assertThat(serviceDecompositionExtracted).usingRecursiveComparison().ignoringFields("modelInfo", "vnfResources", "allottedResources", "networkResources.resourceId").isEqualTo(serviceDecomposition);
}
}
package org.onap.so.bpmn.servicedecomposition.tasks;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.CoreMatchers.equalTo;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
private static final String RESOURCE_PATH = "src/test/resources/__files/ExecuteBuildingBlock/";
-
@Test
public void testMapOrchestrationStatusFromAAI() {
OrchestrationStatus expected = OrchestrationStatus.INVENTORIED;
String orchStatusInput = "Inventoried";
OrchestrationStatus actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.ASSIGNED;
orchStatusInput = "Assigned";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.ACTIVE;
orchStatusInput = "Active";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.CREATED;
orchStatusInput = "Created";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.PRECREATED;
orchStatusInput = "PreCreated";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.PENDING_CREATE;
orchStatusInput = "PendingCreate";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.PENDING_DELETE;
orchStatusInput = "PendingDelete";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.PENDING;
orchStatusInput = "Pending";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
expected = OrchestrationStatus.PENDING_ACTIVATION;
orchStatusInput = "PendingActivation";
actual = bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(orchStatusInput);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
public void testMapOrchestrationFuzzyCases() {
List<String> values = Arrays.asList("pending-create", "pending_Create", "pendinggcreate", "PendingCreate");
values.forEach(value -> {
- assertThat(bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(value),
- equalTo(OrchestrationStatus.PENDING_CREATE));
+ assertThat(bbInputSetupMapperLayer.mapOrchestrationStatusFromAAI(value))
+ .isEqualTo(OrchestrationStatus.PENDING_CREATE);
});
}
Customer actual = bbInputSetupMapperLayer.mapAAICustomer(customerAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ServiceSubscription actual = bbInputSetupMapperLayer.mapAAIServiceSubscription(svcSubscriptionAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Project actual = bbInputSetupMapperLayer.mapAAIProject(projectAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Project actual = bbInputSetupMapperLayer.mapRequestProject(requestProject);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
OwningEntity actual = bbInputSetupMapperLayer.mapAAIOwningEntity(entityAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
OwningEntity actual = bbInputSetupMapperLayer.mapRequestOwningEntity(requestOwningEntity);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Platform actual = bbInputSetupMapperLayer.mapAAIPlatform(platformAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
LineOfBusiness actual = bbInputSetupMapperLayer.mapAAILineOfBusiness(lobAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
NetworkPolicy actualNetworkPolicy = bbInputSetupMapperLayer.mapAAINetworkPolicy(aaiNetworkPolicy);
- assertThat(actualNetworkPolicy, sameBeanAs(expectedNetworkPolicy));
+ assertThat(actualNetworkPolicy).usingRecursiveComparison().isEqualTo(expectedNetworkPolicy);
}
@Test
VolumeGroup actualVolumeGroup = bbInputSetupMapperLayer.mapAAIVolumeGroup(aaiVolumeGroup);
- assertThat(actualVolumeGroup, sameBeanAs(expectedVolumeGroup));
+ assertThat(actualVolumeGroup).usingRecursiveComparison().isEqualTo(expectedVolumeGroup);
}
@Test
ModelInfoServiceInstance actual = bbInputSetupMapperLayer.mapCatalogServiceIntoServiceInstance(catalogService);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ModelInfoInstanceGroup actual =
bbInputSetupMapperLayer.mapCatalogInstanceGroupToInstanceGroup(collectionResourceCust, instanceGroup);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
NetworkResourceCustomization actual = bbInputSetupMapperLayer
.mapCollectionNetworkResourceCustToNetworkResourceCust(collectionNetworkResourceCust);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ModelInfoCollection actual =
bbInputSetupMapperLayer.mapCatalogCollectionToCollection(collectionCust, collectionResource);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ServiceInstance actual = bbInputSetupMapperLayer.mapAAIServiceInstanceIntoServiceInstance(serviceInstanceAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
bbInputSetupMapperLayer.setPlatformAndLOBIntoServiceInstance(platformMSO, lineOfBusinessMSO, actual,
resourcesToBeOrchestrated);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
L3Network actual = bbInputSetupMapperLayer.mapAAIL3Network(aaiL3Network);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GenericVnf actual = bbInputSetupMapperLayer.mapAAIGenericVnfIntoGenericVnf(aaiGenericVnf);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Pnf actual = bbInputSetupMapperLayer.mapAAIPnfIntoPnf(aaiPnf);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Collection actualCollection = bbInputSetupMapperLayer.mapAAICollectionIntoCollection(aaiCollection);
- assertThat(actualCollection, sameBeanAs(expectedCollection));
+ assertThat(actualCollection).usingRecursiveComparison().isEqualTo(expectedCollection);
}
@Test
org.onap.so.bpmn.servicedecomposition.bbobjects.InstanceGroup actualInstanceGroup =
bbInputSetupMapperLayer.mapAAIInstanceGroupIntoInstanceGroup(aaiInstanceGroup);
- assertThat(actualInstanceGroup, sameBeanAs(expectedInstanceGroup));
+ assertThat(actualInstanceGroup).usingRecursiveComparison().isEqualTo(expectedInstanceGroup);
}
@Test
RouteTableReference actualRouteTableReference =
bbInputSetupMapperLayer.mapAAIRouteTableReferenceIntoRouteTableReference(aaiRouteTableReference);
- assertThat(actualRouteTableReference, sameBeanAs(expectedRouteTableReference));
+ assertThat(actualRouteTableReference).usingRecursiveComparison().isEqualTo(expectedRouteTableReference);
}
@Test
ModelInfoNetwork actualModelInfoNetwork =
bbInputSetupMapperLayer.mapCatalogNetworkToNetwork(networkResourceCustomization);
- assertThat(actualModelInfoNetwork, sameBeanAs(expectedModelInfoNetwork));
+ assertThat(actualModelInfoNetwork).usingRecursiveComparison().isEqualTo(expectedModelInfoNetwork);
}
@Test
ModelInfoGenericVnf actualModelInfoGenericVnf =
bbInputSetupMapperLayer.mapCatalogVnfToVnf(vnfResourceCustomization);
- assertThat(actualModelInfoGenericVnf, sameBeanAs(expectedModelInfoGenericVnf));
+ assertThat(actualModelInfoGenericVnf).usingRecursiveComparison().isEqualTo(expectedModelInfoGenericVnf);
}
@Test
ModelInfoPnf actualModelInfoPnf = bbInputSetupMapperLayer.mapCatalogPnfToPnf(pnfResourceCustomization);
- assertThat(actualModelInfoPnf, sameBeanAs(expectedModelInfoPnf));
+ assertThat(actualModelInfoPnf).usingRecursiveComparison().isEqualTo(expectedModelInfoPnf);
}
@Test
ModelInfoVfModule actualModelInfoVfModule =
bbInputSetupMapperLayer.mapCatalogVfModuleToVfModule(vfResourceCustomization);
- assertThat(actualModelInfoVfModule, sameBeanAs(expectedModelInfoVfModule));
+ assertThat(actualModelInfoVfModule).usingRecursiveComparison().isEqualTo(expectedModelInfoVfModule);
}
@Test
Platform actualPlatform = bbInputSetupMapperLayer.mapRequestPlatform(platform);
- assertThat(actualPlatform, sameBeanAs(expectedPlatform));
+ assertThat(actualPlatform).usingRecursiveComparison().isEqualTo(expectedPlatform);
}
@Test
LineOfBusiness actualLineOfBusiness = bbInputSetupMapperLayer.mapRequestLineOfBusiness(lineOfBusiness);
- assertThat(actualLineOfBusiness, sameBeanAs(expectedLineOfBusiness));
+ assertThat(actualLineOfBusiness).usingRecursiveComparison().isEqualTo(expectedLineOfBusiness);
}
@Test
Configuration actualConfiguration = bbInputSetupMapperLayer.mapAAIConfiguration(configurationAAI);
- assertThat(actualConfiguration, sameBeanAs(expectedConfiguration));
+ assertThat(actualConfiguration).usingRecursiveComparison().isEqualTo(expectedConfiguration);
}
@Test
.readValue(new File(RESOURCE_PATH + "RequestDetailsInput_mapReqContext.json"), RequestDetails.class);
RequestContext actual = bbInputSetupMapperLayer.mapRequestContext(requestDetails);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
OrchestrationContext actual = bbInputSetupMapperLayer.mapOrchestrationContext(requestDetails);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
OrchestrationContext actual = bbInputSetupMapperLayer.mapOrchestrationContext(requestDetails);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
CloudRegion actual = bbInputSetupMapperLayer.mapCloudRegion(cloudConfig, cloudRegion);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
CloudRegion actual = bbInputSetupMapperLayer.mapCloudRegion(cloudConfig, cloudRegion);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Tenant actual = bbInputSetupMapperLayer.mapTenant(aaiTenant);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
CloudRegion actual = bbInputSetupMapperLayer.mapCloudRegion(null, null);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ModelInfoConfiguration actual = bbInputSetupMapperLayer
.mapCatalogConfigurationToConfiguration(configurationResourceCustomization, policyNameTable);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ModelInfoConfiguration actual =
bbInputSetupMapperLayer.mapCatalogConfigurationToConfiguration(fabricCustomization);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
package org.onap.so.bpmn.servicedecomposition.tasks;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
ServiceInstance actual = SPY_bbInputSetup.getALaCarteServiceInstance(service, requestDetails, customer, null,
null, lookupKeyMap, serviceInstanceId, aLaCarte, bbName);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test(expected = Exception.class)
ServiceInstance actual = SPY_bbInputSetup.getALaCarteServiceInstance(service, requestDetails, customer, null,
null, lookupKeyMap, serviceInstanceId, aLaCarte, bbName);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Customer actual = this.SPY_bbInputSetup.getCustomerAndServiceSubscription(requestDetails, resourceId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
requestDetails.setSubscriberInfo(null);
-
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
actual.getCustomer().getServiceSubscription().getServiceInstances().get(0).getVnfs().add(genericVnfActual);
SPY_bbInputSetup.setHomingFlag(actual, homing, lookupKeyMap);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
DelegateExecution execution = Mockito.mock(DelegateExecution.class);
doReturn(expected).when(execution).getVariable(any(String.class));
ExecuteBuildingBlock actual = SPY_bbInputSetup.getExecuteBBFromExecution(execution);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual =
SPY_bbInputSetup.getGBB(executeBB, lookupKeyMap, requestAction, aLaCarte, resourceId, null);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
.mapAAIGenericVnfIntoGenericVnf(ArgumentMatchers.isA(org.onap.aai.domain.yang.GenericVnf.class));
GeneralBuildingBlock actual =
SPY_bbInputSetup.getGBBCM(executeBB, requestDetails, lookupKeyMap, requestAction, resourceId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual =
SPY_bbInputSetup.getGBBCM(executeBB, requestDetails, lookupKeyMap, requestAction, instanceGroupId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteNonService(executeBB, requestDetails, lookupKeyMap,
requestAction, resourceId, vnfType);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
verify(SPY_bbInputSetupUtils, times(1)).getCatalogServiceByModelUUID(aaiServiceInstance.getModelVersionId());
verify(SPY_bbInputSetupUtils, times(1)).getCatalogServiceByModelUUID("modelUUID");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteNonService(executeBB, requestDetails, lookupKeyMap,
requestAction, resourceId, vnfType);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
requestAction, resourceId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
requestAction, resourceId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBALaCarteService(executeBB, requestDetails, lookupKeyMap,
requestAction, resourceId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceByName(requestInfo.getInstanceName(), customer);
doReturn(null).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(serviceInstanceId);
-
doReturn(expected).when(SPY_bbInputSetup).createServiceInstance(requestDetails, null, null, lookupKeyMap,
serviceInstanceId);
ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
doReturn(serviceInstanceAAI).when(SPY_bbInputSetupUtils).getAAIServiceInstanceById(serviceInstanceId);
-
ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
lookupKeyMap, serviceInstanceId, aLaCarte, service, bbName);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Mockito.any(), Mockito.any());
ServiceInstance actual = SPY_bbInputSetup.getServiceInstanceHelper(requestDetails, customer, null, null,
new HashMap<>(), "SharansInstanceId", false, new Service(), "ActivateServiceInstanceBB");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test(expected = Exception.class)
.setRequestDetails(requestDetails).setExecuteBB(executeBB).setRequestAction(requestAction).build();
GeneralBuildingBlock actual = SPY_bbInputSetup.populateGBBWithSIAndAdditionalInfo(parameter);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
SPY_bbInputSetup.getALaCarteServiceInstance(service, requestDetails, customer, project, owningEntity,
lookupKeyMap, serviceInstanceId, aLaCarte, executeBB.getBuildingBlock().getBpmnFlowName());
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
doReturn(expected).when(bbInputSetupMapperLayer).mapAAIServiceSubscription(aaiServiceSubscription);
ServiceSubscription actual = SPY_bbInputSetup.getServiceSubscription(requestDetails, customer);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
doReturn(expected).when(bbInputSetupMapperLayer).mapAAICustomer(aaiCustomer);
Customer actual = SPY_bbInputSetup.getCustomerFromRequest(requestDetails);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
doReturn(expected).when(bbInputSetupMapperLayer).mapAAIServiceInstanceIntoServiceInstance(serviceInstanceAAI);
-
ServiceInstance actual = SPY_bbInputSetup.getExistingServiceInstance(serviceInstanceAAI);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
lookupKeyMap.put(ResourceKey.GENERIC_VNF_ID, "genericVnfId");
String bbName = AssignFlows.VNF.toString();
-
ServiceModel serviceModel = new ServiceModel();
serviceModel.setCurrentService(service);
SPY_bbInputSetup.mapCatalogNetworkCollectionInstanceGroup(service,
serviceInstance.getCollection().getInstanceGroup(), collectionCust.getModelCustomizationUUID());
- assertThat(collection.getModelInfoCollection(), sameBeanAs(modelInfoCollection));
- assertThat(instanceGroup.getModelInfoInstanceGroup(), sameBeanAs(modelInfoInstanceGroup));
+ assertThat(collection.getModelInfoCollection()).usingRecursiveComparison().isEqualTo(modelInfoCollection);
+ assertThat(instanceGroup.getModelInfoInstanceGroup()).usingRecursiveComparison()
+ .isEqualTo(modelInfoInstanceGroup);
}
@Test
uriKeys.put("global-customer-id", "globalCustomerId");
uriKeys.put("service-type", "serviceType");
-
doNothing().when(SPY_bbInputSetup).mapProject(any(), eq(serviceInstance));
doNothing().when(SPY_bbInputSetup).mapOwningEntity(any(), eq(serviceInstance));
doNothing().when(SPY_bbInputSetup).mapL3Networks(any(), eq(serviceInstance.getNetworks()));
SPY_bbInputSetup.populateLookupKeyMapWithIds(workflowResourceIds, actual);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
service.setServiceProxyCustomizations(new ArrayList<ServiceProxyResourceCustomization>());
service.getServiceProxyCustomizations().add(serviceProxyCatalog);
ServiceProxy actual = SPY_bbInputSetup.getServiceProxy(service);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GeneralBuildingBlock actual = SPY_bbInputSetup.getGBBMacro(executeBB, requestDetails, lookupKeyMap,
requestAction, resourceId, vnfType);
- assertThat(actual, sameBeanAs(gBB));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(gBB);
}
@Test
VfModule actual = SPY_bbInputSetup.createVfModule(lookupKeyMap, vfModuleId, instanceName, instanceParams);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
assertEquals("LookupKeyMap is populated", vfModuleId, lookupKeyMap.get(ResourceKey.VF_MODULE_ID));
expected.getCloudParams().clear();
actual = SPY_bbInputSetup.createVfModule(lookupKeyMap, vfModuleId, instanceName, null);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
VolumeGroup actual =
SPY_bbInputSetup.createVolumeGroup(lookupKeyMap, volumeGroupId, instanceName, vnfType, instanceParams);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
assertEquals("LookupKeyMap is populated", volumeGroupId, lookupKeyMap.get(ResourceKey.VOLUME_GROUP_ID));
expected.getCloudParams().clear();
actual = SPY_bbInputSetup.createVolumeGroup(lookupKeyMap, volumeGroupId, instanceName, vnfType, null);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
L3Network actual =
SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, networkId, instanceParams, parameter);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
assertEquals("LookupKeyMap is populated", networkId, lookupKeyMap.get(ResourceKey.NETWORK_ID));
expected.getCloudParams().clear();
actual = SPY_bbInputSetup.createNetwork(lookupKeyMap, instanceName, networkId, null, parameter);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
GenericVnf actual = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, requestPlatform,
requestLineOfBusiness, vnfId, vnfType, instanceParams, productFamilyId, applicationId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
assertEquals("LookupKeyMap is populated", vnfId, lookupKeyMap.get(ResourceKey.GENERIC_VNF_ID));
expected.getCloudParams().clear();
actual = SPY_bbInputSetup.createGenericVnf(lookupKeyMap, instanceName, requestPlatform, requestLineOfBusiness,
vnfId, vnfType, null, productFamilyId, applicationId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
- assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
+ assertThat(vfModule.getModelInfoVfModule()).usingRecursiveComparison().isEqualTo(modelInfoVfModule);
modelInfo.setModelCustomizationUuid(null);
modelInfo.setModelCustomizationId(vfModuleCustomizationUUID);
SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
- assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
+ assertThat(vfModule.getModelInfoVfModule()).usingRecursiveComparison().isEqualTo(modelInfoVfModule);
}
@Test
SPY_bbInputSetup.mapCatalogVfModule(vfModule, modelInfo, service, vnfModelCustomizationUUID);
- assertThat(vfModule.getModelInfoVfModule(), sameBeanAs(modelInfoVfModule));
+ assertThat(vfModule.getModelInfoVfModule()).usingRecursiveComparison().isEqualTo(modelInfoVfModule);
verify(SPY_bbInputSetupUtils, times(1))
.getVfModuleCustomizationByModelCuztomizationUUID(modelInfo.getModelCustomizationId());
.setInstanceName(instanceName).setInstanceParams(instanceParams)
.setCloudConfiguration(cloudConfiguration).setIsReplace(true).setServiceModel(serviceModel).build();
-
SPY_bbInputSetup.populateVfModule(parameter);
verify(SPY_bbInputSetup, times(2)).mapCatalogVfModule(isA(VfModule.class), isA(ModelInfo.class),
package org.onap.so.bpmn.servicedecomposition.tasks;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
doReturn(expected).when(MOCK_catalogDbClient).getServiceByID(modelUUID);
- assertThat(bbInputSetupUtils.getCatalogServiceByModelUUID(modelUUID), sameBeanAs(expected));
+ assertThat(bbInputSetupUtils.getCatalogServiceByModelUUID(modelUUID)).usingRecursiveComparison()
+ .isEqualTo(expected);
}
@Test
modelInvariantUUID);
assertThat(bbInputSetupUtils.getCatalogServiceByModelVersionAndModelInvariantUUID(modelVersion,
- modelInvariantUUID), sameBeanAs(expectedService));
+ modelInvariantUUID)).usingRecursiveComparison().isEqualTo(expectedService);
}
@Test
doReturn(Arrays.asList(vnfc)).when(MOCK_catalogDbClient)
.getVnfcInstanceGroupsByVnfResourceCust(modelCustomizationUUID);
- assertThat(bbInputSetupUtils.getVnfcInstanceGroups(modelCustomizationUUID), sameBeanAs(Arrays.asList(vnfc)));
+ assertThat(bbInputSetupUtils.getVnfcInstanceGroups(modelCustomizationUUID)).usingRecursiveComparison()
+ .isEqualTo(Arrays.asList(vnfc));
}
@Test
doReturn(infraActiveRequest).when(MOCK_requestsDbClient).getInfraActiveRequestbyRequestId(requestId);
- assertThat(bbInputSetupUtils.getRequestDetails(requestId), sameBeanAs(expected));
+ assertThat(bbInputSetupUtils.getRequestDetails(requestId)).usingRecursiveComparison().isEqualTo(expected);
}
@Test
.cloudRegion(cloudConfig.getCloudOwner(), cloudConfig.getLcpCloudRegionId()))
.depth(Depth.ONE).nodesOnly(true));
- assertThat(bbInputSetupUtils.getCloudRegion(cloudConfig), sameBeanAs(expected.get()));
+ assertThat(bbInputSetupUtils.getCloudRegion(cloudConfig)).usingRecursiveComparison().isEqualTo(expected.get());
}
@Test
doReturn(expected).when(MOCK_aaiResourcesClient).get(InstanceGroup.class,
AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().instanceGroup(instanceGroupId)));
- assertThat(bbInputSetupUtils.getAAIInstanceGroup(instanceGroupId), sameBeanAs(expected.get()));
+ assertThat(bbInputSetupUtils.getAAIInstanceGroup(instanceGroupId)).usingRecursiveComparison()
+ .isEqualTo(expected.get());
}
@Test
doReturn(expected).when(MOCK_aaiResourcesClient).get(org.onap.aai.domain.yang.Customer.class,
AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.business().customer(globalSubscriberId)));
- assertThat(bbInputSetupUtils.getAAICustomer(globalSubscriberId), sameBeanAs(expected.get()));
+ assertThat(bbInputSetupUtils.getAAICustomer(globalSubscriberId)).usingRecursiveComparison()
+ .isEqualTo(expected.get());
}
@Test
AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.business().customer(globalSubscriberId)
.serviceSubscription(subscriptionServiceType)));
- assertThat(bbInputSetupUtils.getAAIServiceSubscription(globalSubscriberId, subscriptionServiceType),
- sameBeanAs(expected.get()));
+ assertThat(bbInputSetupUtils.getAAIServiceSubscription(globalSubscriberId, subscriptionServiceType))
+ .usingRecursiveComparison().isEqualTo(expected.get());
}
@Test
doReturn(Optional.of(expectedServiceInstance)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
isA(AAIResourceUri.class));
- assertThat(bbInputSetupUtils.getAAIServiceInstanceById(serviceInstanceId), sameBeanAs(expectedServiceInstance));
+ assertThat(bbInputSetupUtils.getAAIServiceInstanceById(serviceInstanceId)).usingRecursiveComparison()
+ .isEqualTo(expectedServiceInstance);
}
@Test
.depth(Depth.TWO));
assertThat(bbInputSetupUtils.getAAIServiceInstanceByIdAndCustomer(globalCustomerId, serviceType,
- serviceInstanceId), sameBeanAs(expected));
+ serviceInstanceId)).usingRecursiveComparison().isEqualTo(expected);
}
@Test
public void getOptionalAAIServiceInstanceByNameNullTest() {
Optional<ServiceInstance> actual = bbInputSetupUtils.getAAIServiceInstanceByName("", "", "");
- assertThat(actual, sameBeanAs(Optional.empty()));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(Optional.empty());
}
@Test
doReturn(expectedInstanceGroup).when(MOCK_catalogDbClient).getInstanceGroupByModelUUID(modelUUID);
- assertThat(bbInputSetupUtils.getCatalogInstanceGroup(modelUUID), sameBeanAs(expectedInstanceGroup));
+ assertThat(bbInputSetupUtils.getCatalogInstanceGroup(modelUUID)).usingRecursiveComparison()
+ .isEqualTo(expectedInstanceGroup);
}
@Test
doReturn(Arrays.asList(expectedCollection)).when(MOCK_catalogDbClient)
.getCollectionResourceInstanceGroupCustomizationByModelCustUUID(modelCustomizationUUID);
- assertThat(bbInputSetupUtils.getCollectionResourceInstanceGroupCustomization(modelCustomizationUUID),
- sameBeanAs(Arrays.asList(expectedCollection)));
+ assertThat(bbInputSetupUtils.getCollectionResourceInstanceGroupCustomization(modelCustomizationUUID))
+ .usingRecursiveComparison().isEqualTo(Arrays.asList(expectedCollection));
}
@Test
doReturn(Optional.of(expectedAaiConfiguration)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
isA(AAIResourceUri.class));
- assertThat(bbInputSetupUtils.getAAIConfiguration(configurationId), sameBeanAs(expectedAaiConfiguration));
+ assertThat(bbInputSetupUtils.getAAIConfiguration(configurationId)).usingRecursiveComparison()
+ .isEqualTo(expectedAaiConfiguration);
}
@Test
doReturn(Optional.of(expectedAaiVnf)).when(MOCK_aaiResourcesClient).get(isA(Class.class),
eq(AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId)).depth(Depth.ONE)));
- assertThat(bbInputSetupUtils.getAAIGenericVnf(vnfId), sameBeanAs(expectedAaiVnf));
+ assertThat(bbInputSetupUtils.getAAIGenericVnf(vnfId)).usingRecursiveComparison().isEqualTo(expectedAaiVnf);
}
@Test
package org.onap.so.bpmn.servicedecomposition.tasks;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
doReturn(relationshipsOp).when(SPY_CloudInfoFromAAI).getRelationshipsFromWrapper(isA(AAIResultWrapper.class));
doReturn(Optional.of(expected)).when(SPY_CloudInfoFromAAI).getRelatedCloudRegionAndTenant(relationships);
Optional<CloudRegion> actual = SPY_CloudInfoFromAAI.getCloudInfoFromAAI(serviceInstance);
- assertThat(actual.get(), sameBeanAs(expected));
+ assertThat(actual.get()).usingRecursiveComparison().isEqualTo(expected);
// Test networks
serviceInstance =
aaiL3Network.setNetworkId(networkId);
doReturn(aaiL3Network).when(SPY_bbInputSetupUtils).getAAIL3Network(l3Network.getNetworkId());
actual = SPY_CloudInfoFromAAI.getCloudInfoFromAAI(serviceInstance);
- assertThat(actual.get(), sameBeanAs(expected));
+ assertThat(actual.get()).usingRecursiveComparison().isEqualTo(expected);
// Test no relationships
Optional<CloudRegion> actual = SPY_CloudInfoFromAAI.getRelatedCloudRegionAndTenant(relationships);
- assertThat(actual.get(), sameBeanAs(expected));
+ assertThat(actual.get()).usingRecursiveComparison().isEqualTo(expected);
}
}
package org.onap.so.client.dmaapproperties;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.doNothing;
@Autowired
private DmaapPropertiesClient dmaapPropertiesClient;
-
private final String file = "src/test/resources/org/onap/so/client/avpn/dmaap/avpnDmaapAsyncRequestStatus.json";
private String requestId = "rq1234d1-5a33-55df-13ab-12abad84e331";
private String clientSource = "SPP";
AVPNDmaapBean expected = new ObjectMapper().readValue(new File(file), AVPNDmaapBean.class);
assertNotNull(actualBean);
- assertThat(actualBean, sameBeanAs(expected));
+ assertThat(actualBean).usingRecursiveComparison().isEqualTo(expected);
}
@Test
*/
package org.onap.so.bpmn.core.domain;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
configResource.setResourceId("configResourceId");
}
-
@Test
public void serviceDecompositionWithGroupandVnfc() throws IOException {
String sericeStr = new String(Files.readAllBytes(Paths.get(RESOURCE_PATH + "ServiceWithGroupandVnfc.json")));
serviceDecomp.addAllottedResource(allottedResource);
serviceDecomp.addConfigResource(configResource);
- assertThat(serviceDecomp.getServiceResource(vnfResource.getResourceId()), sameBeanAs(vnfResource));
- assertThat(serviceDecomp.getServiceResource(networkResource.getResourceId()), sameBeanAs(networkResource));
- assertThat(serviceDecomp.getServiceResource(allottedResource.getResourceId()), sameBeanAs(allottedResource));
- assertThat(serviceDecomp.getServiceResource(configResource.getResourceId()), sameBeanAs(configResource));
+ assertThat(serviceDecomp.getServiceResource(vnfResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(vnfResource);
+ assertThat(serviceDecomp.getServiceResource(networkResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(networkResource);
+ assertThat(serviceDecomp.getServiceResource(allottedResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(allottedResource);
+ assertThat(serviceDecomp.getServiceResource(configResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(configResource);
VnfResource vnfResourceReplace = new VnfResource();
vnfResourceReplace.setResourceId(vnfResource.getResourceId());
System.out.println(serviceDecomp.toJsonString());
- assertThat(serviceDecomp.getServiceResource(vnfResource.getResourceId()), sameBeanAs(vnfResource));
- assertThat(serviceDecomp.getServiceResource(networkResource.getResourceId()), sameBeanAs(networkResource));
- assertThat(serviceDecomp.getServiceResource(allottedResource.getResourceId()), sameBeanAs(allottedResource));
- assertThat(serviceDecomp.getServiceResource(configResource.getResourceId()), sameBeanAs(configResource));
+ assertThat(serviceDecomp.getServiceResource(vnfResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(vnfResource);
+ assertThat(serviceDecomp.getServiceResource(networkResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(networkResource);
+ assertThat(serviceDecomp.getServiceResource(allottedResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(allottedResource);
+ assertThat(serviceDecomp.getServiceResource(configResource.getResourceId())).usingRecursiveComparison()
+ .isEqualTo(configResource);
serviceDecomp = new ServiceDecomposition(catalogRestOutput, "serviceInstanceId");
serviceDecomp.addVnfResource(vnfResourceJson);
ServiceDecomposition expectedServiceDecomp =
new ServiceDecomposition(expectedCatalogRestOutput, "serviceInstanceId");
- assertThat(serviceDecomp, sameBeanAs(expectedServiceDecomp));
+ assertThat(serviceDecomp).usingRecursiveComparison().isEqualTo(expectedServiceDecomp);
assertEquals(
serviceDecomp.listToJson(Arrays.asList(networkResource))
+ serviceDecomp.listToJson(Arrays.asList(vnfResource))
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
- <version>3.11.1</version>
+ <version>3.16.0</version>
<scope>test</scope>
</dependency>
<dependency>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import org.onap.so.bpmn.core.domain.Resource
import org.onap.so.bpmn.core.domain.ServiceDecomposition
-import static com.shazam.shazamcrest.MatcherAssert.assertThat
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs
+import static org.assertj.core.api.Assertions.assertThat
import static org.mockito.Mockito.times
import static org.mockito.Mockito.when
/**
csi.prepareDecomposeService_Original(mockExecution)
Mockito.verify(mockExecution, times(1)).setVariable(captor.capture(), captor.capture())
String serviceModelInfo = getServiceModelInfo()
- assertThat(captor.getValue(), sameBeanAs(serviceModelInfo))
+ assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(serviceModelInfo)
}
@Test
csi.processDecomposition_Original(mockExecution)
Mockito.verify(mockExecution, times(1)).setVariable(captor.capture(), captor.capture())
ServiceDecomposition serviceDecomposition = getServiceDecomposition()
- assertThat(captor.getValue(), sameBeanAs(serviceDecomposition))
+ assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(serviceDecomposition)
}
@Test
import org.onap.so.bpmn.common.scripts.MsoGroovyTest
import org.onap.aaiclient.client.aai.AAIResourcesClient
-import static com.shazam.shazamcrest.MatcherAssert.assertThat
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs
+import static org.assertj.core.api.Assertions.assertThat
import static org.junit.Assert.assertEquals
import static org.junit.Assert.assertNotNull
import static org.mockito.ArgumentMatchers.eq
ServiceInstance resData = captor.getValue()
resData.setCreatedAt("")
resData.setEnvironmentContext("")
- assertThat(resData, sameBeanAs(expectedServiceInstanceData))
+ assertThat(resData).usingRecursiveComparison().isEqualTo(expectedServiceInstanceData)
}
@Test
Mockito.verify(mockExecution).setVariable(eq("communicationServiceInstanceProfile"), captor.capture())
CommunicationServiceProfile resData = captor.getValue()
resData.setProfileId("")
- assertThat(resData, sameBeanAs(expectedServiceInstanceData))
+ assertThat(resData).usingRecursiveComparison().isEqualTo(expectedServiceInstanceData)
}
private static CommunicationServiceProfile getExpectedServiceInstanceProfile() {
package org.onap.so.bpmn.infrastructure.scripts
-import static com.shazam.shazamcrest.MatcherAssert.assertThat
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs
+import static org.assertj.core.api.Assertions.assertThat
import static org.mockito.Mockito.times
import static org.mockito.Mockito.when
DoCreateE2EServiceInstance serviceInstance = new DoCreateE2EServiceInstance()
serviceInstance.preProcessRequest(mockExecution)
Mockito.verify(mockExecution, times(7)).setVariable(captor.capture(), captor.capture())
- assertThat(captor.getValue(), sameBeanAs(expectedServiceInstanceData))
+ assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(expectedServiceInstanceData)
}
private ServiceInstance getExpectedServiceInstance() {
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
import org.onap.aai.domain.yang.ServiceInstance
import org.onap.so.bpmn.common.scripts.MsoGroovyTest
-import static com.shazam.shazamcrest.MatcherAssert.assertThat
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs
+import static org.assertj.core.api.Assertions.assertThat
import static org.mockito.Mockito.times
import static org.mockito.Mockito.when
DoUpdateE2EServiceInstance serviceInstance = new DoUpdateE2EServiceInstance()
serviceInstance.preProcessAAIPUT(mockExecution)
Mockito.verify(mockExecution, times(1)).setVariable(captor.capture(), captor.capture())
- assertThat(captor.getValue(), sameBeanAs(expectedServiceInstanceData))
+ assertThat(captor.getValue()).usingRecursiveComparison().isEqualTo(expectedServiceInstanceData)
}
private ServiceInstance getExpectedServiceInstance() {
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
- <version>3.11.1</version>
+ <version>3.16.0</version>
<scope>test</scope>
</dependency>
<dependency>
package org.onap.so.bpmn.infrastructure.adapter.network.tasks;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNotNull;
import javax.xml.bind.JAXBException;
import org.junit.Test;
execution.setVariable("WorkflowResponse", RESPONSE);
networkAdapterImpl.postProcessNetworkAdapter(execution);
assertNotNull(execution.getVariable("createNetworkResponse"));
- assertThat(networkAdapterImpl.unmarshalXml(RESPONSE, CreateNetworkResponse.class),
- sameBeanAs(execution.getVariable("createNetworkResponse")));
+ assertThat(networkAdapterImpl.unmarshalXml(RESPONSE, CreateNetworkResponse.class)).usingRecursiveComparison()
+ .isEqualTo(execution.getVariable("createNetworkResponse"));
}
}
package org.onap.so.bpmn.infrastructure.appc.tasks;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
when(extractPojosForBB.extractByKey(eq(execution), eq(ResourceKey.VF_MODULE_ID))).thenReturn(vfModule);
appcOrchestratorPreProcessor.buildAppcTaskRequest(execution, "Lock");
ApplicationControllerTaskRequest actualTaskRequest = execution.getVariable("appcOrchestratorRequest");
- assertThat(actualTaskRequest, sameBeanAs(expectedTaskRequest));
+ assertThat(actualTaskRequest).usingRecursiveComparison().isEqualTo(expectedTaskRequest);
}
@Test
when(extractPojosForBB.extractByKey(eq(execution), eq(ResourceKey.VF_MODULE_ID))).thenReturn(vfModule);
appcOrchestratorPreProcessor.buildAppcTaskRequest(execution, "ConfigModify");
ApplicationControllerTaskRequest actualTaskRequest = execution.getVariable("appcOrchestratorRequest");
- assertThat(actualTaskRequest, sameBeanAs(expectedTaskRequest));
+ assertThat(actualTaskRequest).usingRecursiveComparison().isEqualTo(expectedTaskRequest);
}
private void fillRequiredAppcExecutionFieldsConfigModify() {
*/
package org.onap.so.bpmn.infrastructure.flowspecific.tasks;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
verify(networkAdapterObjectMapper, times(1)).createNetworkRequestMapper(requestContext, cloudRegion,
orchestrationContext, serviceInstance, network, userInput, cloudRegionPo, customer);
- assertThat(expectedCreateNetworkRequest, sameBeanAs(execution.getVariable("createNetworkRequest")));
+ assertThat(expectedCreateNetworkRequest).usingRecursiveComparison()
+ .isEqualTo(execution.getVariable("createNetworkRequest"));
}
}
package org.onap.so.bpmn.infrastructure.sdnc.mapper;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import org.onap.so.client.exception.MapperException;
import org.onap.so.client.sdnc.beans.SDNCSvcAction;
-
public class GeneralTopologyObjectMapperTest extends TestDataSetup {
@InjectMocks
private GeneralTopologyObjectMapper genObjMapper = new GeneralTopologyObjectMapper();
onapModelInformation.setModelCustomizationUuid("my-customization-uuid");
networkInformation.setOnapModelInformation(onapModelInformation);
- assertThat(networkInformation, sameBeanAs(genObjMapper.buildNetworkInformation(network)));
+ assertThat(networkInformation).usingRecursiveComparison()
+ .isEqualTo(genObjMapper.buildNetworkInformation(network));
}
networkInformation.networkTechnology("my-network-technology");
networkInformation.setFromPreload(null);
-
- assertThat(networkInformation, sameBeanAs(genObjMapper.buildNetworkInformation(network)));
+ assertThat(networkInformation).usingRecursiveComparison()
+ .isEqualTo(genObjMapper.buildNetworkInformation(network));
}
-
@Test
public void buildVfModuleInformationTest_withNoModelIsFromPreload() {
VfModule vfModule = new VfModule();
package org.onap.so.bpmn.infrastructure.sdnc.mapper;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
omapper.readValue(getJson("genericResourceApiNetworkOperationInformation.json"),
GenericResourceApiNetworkOperationInformation.class);
- assertThat(networkSDNCrequest, sameBeanAs(reqMapper1).ignoring("sdncRequestHeader.svcRequestId")
- .ignoring("requestInformation.requestId"));
+ assertThat(networkSDNCrequest).usingRecursiveComparison().ignoringAllOverriddenEquals()
+ .ignoringFields("sdncRequestHeader.svcRequestId", "requestInformation.requestId").isEqualTo(reqMapper1);
assertEquals("MsoRequestId", networkSDNCrequest.getRequestInformation().getRequestId());
}
omapperUnassign.readValue(getJson("genericResourceApiNetworkOperationInformationUnAssign.json"),
GenericResourceApiNetworkOperationInformation.class);
- assertThat(reqMapperUnassign, sameBeanAs(networkSDNCrequestUnassign).ignoring("sdncRequestHeader.svcRequestId")
- .ignoring("requestInformation.requestId"));
+ assertThat(reqMapperUnassign).usingRecursiveComparison().ignoringAllOverriddenEquals()
+ .ignoringFields("sdncRequestHeader.svcRequestId", "requestInformation.requestId")
+ .isEqualTo(networkSDNCrequestUnassign);
assertEquals("MsoRequestId", networkSDNCrequestUnassign.getRequestInformation().getRequestId());
}
omapper.readValue(getJson("genericResourceApiNetworkOperationInformationNoNetworkName.json"),
GenericResourceApiNetworkOperationInformation.class);
- assertThat(reqMapper1, sameBeanAs(networkSDNCrequest).ignoring("sdncRequestHeader.svcRequestId")
- .ignoring("requestInformation.requestId"));
+ assertThat(reqMapper1).usingRecursiveComparison().ignoringAllOverriddenEquals()
+ .ignoringFields("sdncRequestHeader.svcRequestId", "requestInformation.requestId")
+ .isEqualTo(networkSDNCrequest);
}
/*
package org.onap.so.bpmn.infrastructure.sdnc.mapper;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.nio.file.Files;
GenericResourceApiOnapmodelinformationOnapModelInformation reqMapper1 =
omapper.readValue(jsonToCompare, GenericResourceApiOnapmodelinformationOnapModelInformation.class);
- assertThat(reqMapper1, sameBeanAs(serviceOpInformation.getServiceInformation().getOnapModelInformation()));
+ assertThat(reqMapper1).usingRecursiveComparison()
+ .isEqualTo(serviceOpInformation.getServiceInformation().getOnapModelInformation());
assertEquals("MsoRequestId", serviceOpInformation.getRequestInformation().getRequestId());
assertNotNull(serviceOpInformationNullReqContext.getRequestInformation().getRequestId());
}
package org.onap.so.bpmn.infrastructure.sdnc.mapper;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
GenericResourceApiVfModuleOperationInformation reqMapper1 =
omapper.readValue(jsonToCompare, GenericResourceApiVfModuleOperationInformation.class);
- assertThat(vfModuleSDNCrequest, sameBeanAs(reqMapper1).ignoring("sdncRequestHeader.svcRequestId")
- .ignoring("requestInformation.requestId"));
+ assertThat(vfModuleSDNCrequest).usingRecursiveComparison().ignoringAllOverriddenEquals()
+ .ignoringFields("sdncRequestHeader.svcRequestId", "requestInformation.requestId").isEqualTo(reqMapper1);
assertEquals("MsoRequestId", vfModuleSDNCrequest.getRequestInformation().getRequestId());
}
GenericResourceApiVfModuleOperationInformation reqMapper1 =
omapper.readValue(jsonToCompare, GenericResourceApiVfModuleOperationInformation.class);
- assertThat(vfModuleSDNCrequest, sameBeanAs(reqMapper1).ignoring("sdncRequestHeader.svcRequestId")
- .ignoring("requestInformation.requestId"));
+ assertThat(vfModuleSDNCrequest).usingRecursiveComparison().ignoringAllOverriddenEquals()
+ .ignoringFields("sdncRequestHeader.svcRequestId", "requestInformation.requestId").isEqualTo(reqMapper1);
assertEquals("MsoRequestId", vfModuleSDNCrequest.getRequestInformation().getRequestId());
}
package org.onap.so.bpmn.infrastructure.workflow.tasks.ebb.loader;
+import static org.assertj.core.api.Assertions.assertThat;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.camunda.bpm.engine.delegate.DelegateExecution;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
mockBbInputSetup, mock(ExceptionBuilder.class));
}
-
@Test
public void getResourceListForServiceWithRequestActionAssignInstance()
throws IOException, VrfBondingServiceException {
serviceEBBLoader.traverseAAIService(execution, resourceCounter, resourceId, aaiResourceIds);
assertEquals(8, resourceCounter.size());
assertTrue(resourceCounter.get(2).isBaseVfModule());
- assertThat(aaiResourceIds, sameBeanAs(getExpectedResourceIds()));
+ assertThat(aaiResourceIds).usingRecursiveComparison().isEqualTo(getExpectedResourceIds());
} catch (Exception e) {
fail("Unexpected exception was thrown.");
}
RelatedInstance relatedLocalNetwork = new RelatedInstance();
relatedLocalNetwork.setInstanceId("localNetworkInstanceId");
-
doReturn(aaiLocalNetwork).when(mockBbInputSetupUtils).getAAIL3Network("localNetworkInstanceId");
Resource serviceResource = new Resource(WorkflowType.SERVICE, "1", false, null);
service.getCollectionResourceCustomizations().add(collectionResourceCustomization);
service.getCollectionResourceCustomizations().add(collectionResourceCustomization);
-
doReturn(service).when(mockCatalogDbClient).getServiceByID("3c40d244-808e-42ca-b09a-256d83d19d0a");
doReturn(collectionResourceCustomization).when(mockCatalogDbClient)
.getNetworkCollectionResourceCustomizationByID("123");
relatedToProperty1.setPropertyKey("service-instance.service-instance-name");
relatedToProperty.setPropertyValue("child_euler_001");
-
Relationship relationship = new Relationship();
Relationship relationship1 = new Relationship();
relationship.setRelatedTo("service-instance");
package org.onap.so.client.aai.mapper;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.io.IOException;
private AAIObjectMapper aaiObjectMapper = new AAIObjectMapper();
private final static String JSON_FILE_LOCATION = "src/test/resources/__files/BuildingBlocks/";
-
@Test
public void mapConfigurationTest() {
Configuration configuration = new Configuration();
org.onap.aai.domain.yang.Configuration actualConfiguration = aaiObjectMapper.mapConfiguration(configuration);
- assertThat(actualConfiguration, sameBeanAs(expectedConfiguration));
+ assertThat(actualConfiguration).usingRecursiveComparison().isEqualTo(expectedConfiguration);
}
@Test
org.onap.aai.domain.yang.VolumeGroup actualVolumeGroup = aaiObjectMapper.mapVolumeGroup(volumeGroup);
- assertThat(actualVolumeGroup, sameBeanAs(expectedVolumeGroup));
+ assertThat(actualVolumeGroup).usingRecursiveComparison().isEqualTo(expectedVolumeGroup);
}
@Test
org.onap.aai.domain.yang.VfModule reqMapper1 =
omapper.readValue(jsonToCompare, org.onap.aai.domain.yang.VfModule.class);
- assertThat(reqMapper1, sameBeanAs(AAIVfModule));
+ assertThat(reqMapper1).usingRecursiveComparison().isEqualTo(AAIVfModule);
}
org.onap.aai.domain.yang.VfModule reqMapper1 =
omapper.readValue(jsonToCompare, org.onap.aai.domain.yang.VfModule.class);
- assertThat(reqMapper1, sameBeanAs(AAIVfModule));
+ assertThat(reqMapper1).usingRecursiveComparison().isEqualTo(AAIVfModule);
}
instanceGroup.setModelInfoInstanceGroup(model);
-
org.onap.aai.domain.yang.InstanceGroup aaiInstanceGroup = aaiObjectMapper.mapInstanceGroup(instanceGroup);
try {
org.onap.aai.domain.yang.Customer actualCustomer = aaiObjectMapper.mapCustomer(customer);
- assertThat(actualCustomer, sameBeanAs(expectedCustomer));
+ assertThat(actualCustomer).usingRecursiveComparison().isEqualTo(expectedCustomer);
}
@Test
org.onap.aai.domain.yang.L3Network network =
omapper.readValue(getJson("aaiL3NetworkMapped.json"), org.onap.aai.domain.yang.L3Network.class);
- com.shazam.shazamcrest.MatcherAssert.assertThat(aaiL3Network, sameBeanAs(network));
+ assertThat(aaiL3Network).usingRecursiveComparison().isEqualTo(network);
}
org.onap.aai.domain.yang.Collection actualCollection = aaiObjectMapper.mapCollection(networkCollection);
- assertThat(actualCollection, sameBeanAs(expectedCollection));
+ assertThat(actualCollection).usingRecursiveComparison().isEqualTo(expectedCollection);
}
/*
routeTarget.setGlobalRouteTarget("testGrt");
vpnBinding.getRouteTargets().add(routeTarget);
-
org.onap.aai.domain.yang.VpnBinding expectedVpnBinding = new org.onap.aai.domain.yang.VpnBinding();
expectedVpnBinding.setVpnId("testVpnId");
expectedVpnBinding.setVpnName("testVpn");
org.onap.aai.domain.yang.VpnBinding actualVpnBinding = aaiObjectMapper.mapVpnBinding(vpnBinding);
- assertThat(actualVpnBinding, sameBeanAs(expectedVpnBinding));
+ assertThat(actualVpnBinding).usingRecursiveComparison().isEqualTo(expectedVpnBinding);
}
@Test
org.onap.aai.domain.yang.RouteTarget actualRouteTarget = aaiObjectMapper.mapRouteTarget(routeTarget);
- assertThat(actualRouteTarget, sameBeanAs(expectedRouteTarget));
+ assertThat(actualRouteTarget).usingRecursiveComparison().isEqualTo(expectedRouteTarget);
}
@Test
org.onap.aai.domain.yang.Subnet actualSubnet = aaiObjectMapper.mapSubnet(subnet);
- assertThat(actualSubnet, sameBeanAs(expectedSubnet));
+ assertThat(actualSubnet).usingRecursiveComparison().isEqualTo(expectedSubnet);
}
@Test
org.onap.aai.domain.yang.NetworkPolicy actualNetworkPolicy = aaiObjectMapper.mapNetworkPolicy(networkPolicy);
- assertThat(actualNetworkPolicy, sameBeanAs(expectedNetworkPolicy));
+ assertThat(actualNetworkPolicy).usingRecursiveComparison().isEqualTo(expectedNetworkPolicy);
}
}
*/
package org.onap.so.client.adapter.network.mapper;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doReturn;
import java.nio.file.Files;
SPY_networkAdapterObjectMapper.createNetworkRequestMapper(requestContext, cloudRegion,
orchestrationContext, serviceInstance, l3Network, userInput, cloudRegionPo, customer);
- assertThat(createNetworkRequest, sameBeanAs(expectedCreateNetworkRequest).ignoring("contrailRequest")
- .ignoring("contrailNetwork").ignoring("providerVlanNetwork").ignoring("subnets").ignoring("messageId"));
+ assertThat(createNetworkRequest).usingRecursiveComparison()
+ .ignoringFields("contrailRequest", "contrailNetwork", "providerVlanNetwork", "subnets", "messageId")
+ .isEqualTo(expectedCreateNetworkRequest);
}
@Test
.createNetworkRollbackRequestMapper(requestContext, cloudRegion, orchestrationContext, serviceInstance,
l3Network, userInput, cloudRegionPo, createNetworkResponse);
- assertThat(rollbackNetworkRequest, sameBeanAs(expectedRollbackNetworkRequest).ignoring("contrailNetwork")
- .ignoring("providerVlanNetwork").ignoring("subnets").ignoring("networkParams").ignoring("messageId"));
+ assertThat(rollbackNetworkRequest).usingRecursiveComparison()
+ .ignoringFields("contrailNetwork", "providerVlanNetwork", "subnets", "networkParams", "messageId")
+ .isEqualTo(expectedRollbackNetworkRequest);
}
@Test
SPY_networkAdapterObjectMapper.createNetworkUpdateRequestMapper(requestContext, cloudRegion,
orchestrationContext, serviceInstance, l3Network, userInput, customer);
- assertThat(actualUpdateNetworkRequest,
- sameBeanAs(expectedUpdateNetworkRequest).ignoring("msoRequest.requestId"));
+ assertThat(actualUpdateNetworkRequest).usingRecursiveComparison().ignoringAllOverriddenEquals()
+ .ignoringFields("msoRequest.requestId").isEqualTo(expectedUpdateNetworkRequest);
}
@Test
DeleteNetworkRequest deleteNetworkRequest = SPY_networkAdapterObjectMapper
.deleteNetworkRequestMapper(requestContext, cloudRegion, serviceInstance, l3Network);
- assertThat(expectedDeleteNetworkRequest, sameBeanAs(deleteNetworkRequest));
+ assertThat(expectedDeleteNetworkRequest).usingRecursiveComparison().isEqualTo(deleteNetworkRequest);
}
@Test
DeleteNetworkRequest deleteNetworkRequest = SPY_networkAdapterObjectMapper
.deleteNetworkRequestMapper(requestContext, cloudRegion, serviceInstance, l3Network);
- assertThat(expectedDeleteNetworkRequest, sameBeanAs(deleteNetworkRequest));
+ assertThat(expectedDeleteNetworkRequest).usingRecursiveComparison().isEqualTo(deleteNetworkRequest);
}
@Test
SPY_networkAdapterObjectMapper.createNetworkRequestMapper(requestContext, cloudRegion,
orchestrationContext, serviceInstance, myNetwork, userInput, cloudRegionPo, customer);
// ignoring dynamic fields and networkParams that throws parsing exception on json file load
- assertThat(createNetworkRequest, sameBeanAs(expectedCreateNetworkRequest).ignoring("messageId")
- .ignoring("msoRequest.requestId").ignoring("networkParams"));
+ assertThat(createNetworkRequest).usingRecursiveComparison().ignoringAllOverriddenEquals()
+ .ignoringFields("messageId", "msoRequest.requestId", "networkParams")
+ .isEqualTo(expectedCreateNetworkRequest);
}
@Test
assertEquals("192.168.0.0/16", subnets.get(0).getHostRoutes().get(0).getPrefix());
assertEquals("192.168.1.5/16", subnets.get(0).getHostRoutes().get(1).getPrefix());
-
assertEquals("NULL", subnets.get(1).getGatewayIp());
}
}
package org.onap.so.client.adapter.vnf.mapper;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
serviceInstance.getVnfs().get(0).getVolumeGroups().add(volumeGroup);
-
CloudRegion cloudRegion = new CloudRegion();
cloudRegion.setLcpCloudRegionId("lcpCloudRegionId");
cloudRegion.setTenantId("tenantId");
CreateVolumeGroupRequest actualCreateVolumeGroupRequest =
vnfAdapterObjectMapper.createVolumeGroupRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, genericVnf, volumeGroup, sdncVfModuleQueryResponse);
- assertThat(actualCreateVolumeGroupRequest, sameBeanAs(expectedCreateVolumeGroupRequest));
+ assertThat(actualCreateVolumeGroupRequest).usingRecursiveComparison()
+ .isEqualTo(expectedCreateVolumeGroupRequest);
doReturn("false").when(vnfAdapterObjectMapper).getProperty("mso.bridgeEnabled");
actualCreateVolumeGroupRequest = vnfAdapterObjectMapper.createVolumeGroupRequestMapper(requestContext,
cloudRegion, orchestrationContext, serviceInstance, genericVnf, volumeGroup, sdncVfModuleQueryResponse);
- assertThat(actualCreateVolumeGroupRequest, sameBeanAs(expectedCreateVolumeGroupRequest));
+ assertThat(actualCreateVolumeGroupRequest).usingRecursiveComparison()
+ .isEqualTo(expectedCreateVolumeGroupRequest);
doReturn(null).when(vnfAdapterObjectMapper).getProperty("mso.bridgeEnabled");
expectedCreateVolumeGroupRequest.setEnableBridge(true);
actualCreateVolumeGroupRequest = vnfAdapterObjectMapper.createVolumeGroupRequestMapper(requestContext,
cloudRegion, orchestrationContext, serviceInstance, genericVnf, volumeGroup, sdncVfModuleQueryResponse);
- assertThat(actualCreateVolumeGroupRequest, sameBeanAs(expectedCreateVolumeGroupRequest));
+ assertThat(actualCreateVolumeGroupRequest).usingRecursiveComparison()
+ .isEqualTo(expectedCreateVolumeGroupRequest);
doReturn("true").when(vnfAdapterObjectMapper).getProperty("mso.bridgeEnabled");
expectedCreateVolumeGroupRequest.setEnableBridge(true);
actualCreateVolumeGroupRequest = vnfAdapterObjectMapper.createVolumeGroupRequestMapper(requestContext,
cloudRegion, orchestrationContext, serviceInstance, genericVnf, volumeGroup, sdncVfModuleQueryResponse);
- assertThat(actualCreateVolumeGroupRequest, sameBeanAs(expectedCreateVolumeGroupRequest));
+ assertThat(actualCreateVolumeGroupRequest).usingRecursiveComparison()
+ .isEqualTo(expectedCreateVolumeGroupRequest);
}
@Test
genericVnf.setVnfType("vnfType");
serviceInstance.getVnfs().add(genericVnf);
-
ModelInfoVfModule modelInfoVfModule = new ModelInfoVfModule();
modelInfoVfModule.setModelName("modelName");
modelInfoVfModule.setModelCustomizationUUID("modelCustomizationUUID");
CreateVolumeGroupRequest actualCreateVolumeGroupRequest = vnfAdapterObjectMapper.createVolumeGroupRequestMapper(
requestContext, cloudRegion, orchestrationContext, serviceInstance, genericVnf, volumeGroup, null);
- assertThat(actualCreateVolumeGroupRequest, sameBeanAs(expectedCreateVolumeGroupRequest));
+ assertThat(actualCreateVolumeGroupRequest).usingRecursiveComparison()
+ .isEqualTo(expectedCreateVolumeGroupRequest);
}
@Test
DeleteVolumeGroupRequest actualDeleteVolumeGroupRequest = vnfAdapterObjectMapper
.deleteVolumeGroupRequestMapper(requestContext, cloudRegion, serviceInstance, volumeGroup);
- assertThat(actualDeleteVolumeGroupRequest, sameBeanAs(expectedDeleteVolumeGroupRequest));
+ assertThat(actualDeleteVolumeGroupRequest).usingRecursiveComparison()
+ .isEqualTo(expectedDeleteVolumeGroupRequest);
}
@Test
MsoRequest actualMsoRequest = vnfAdapterObjectMapper.createMsoRequest(requestContext, serviceInstance);
- assertThat(expectedMsoRequest, sameBeanAs(actualMsoRequest));
+ assertThat(expectedMsoRequest).usingRecursiveComparison().isEqualTo(actualMsoRequest);
}
}
package org.onap.so.client.adapter.vnf.mapper;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doReturn;
import java.io.IOException;
String jsonToCompare =
new String(Files.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequest.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
-
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
doReturn("true").when(spyMapper).getProperty("mso.bridgeEnabled");
vfModuleVNFAdapterRequest =
jsonToCompare = new String(Files
.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestBridgeEnabled.json")));
reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
-
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
doReturn(null).when(spyMapper).getProperty("mso.bridgeEnabled");
vfModuleVNFAdapterRequest =
jsonToCompare = new String(Files
.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestBridgeEnabled.json")));
reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(
Files.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestTrueBackout.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(Files.readAllBytes(Paths
.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleWithNoEnvironmentAndWorkloadContextRequest.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(
Files.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleAddonRequest.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, volumeGroup, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(Files
.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleWithVolumeGroupRequest.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(Files.readAllBytes(
Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestWithSingleAvailabilityZone.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(Files.readAllBytes(
Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestWithCloudResources.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(
Files.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestDhcpDisabled.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(
Files.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestMultipleDhcp.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
vfModuleObjectMapper.createVfModuleRequestMapper(requestContext, cloudRegion, orchestrationContext,
serviceInstance, vnf, vfModule, null, sdncVnfQueryResponse, sdncVfModuleQueryResponse);
-
String jsonToCompare = new String(
Files.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterCreateVfModuleRequestNoUserParams.json")));
CreateVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, CreateVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest, sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison().ignoringFields("messageId", "notificationUrl")
+ .isEqualTo(reqMapper1);
}
@Test
DeleteVfModuleRequest vfModuleVNFAdapterRequest = vfModuleObjectMapper
.deleteVfModuleRequestMapper(requestContext, cloudRegion, serviceInstance, vnf, vfModule);
-
String jsonToCompare =
new String(Files.readAllBytes(Paths.get(JSON_FILE_LOCATION + "vnfAdapterDeleteVfModuleRequest.json")));
DeleteVfModuleRequest reqMapper1 = omapper.readValue(jsonToCompare, DeleteVfModuleRequest.class);
- assertThat(vfModuleVNFAdapterRequest,
- sameBeanAs(reqMapper1).ignoring("messageId").ignoring("notificationUrl").ignoring("vfModuleStackId"));
+ assertThat(vfModuleVNFAdapterRequest).usingRecursiveComparison()
+ .ignoringFields("messageId", "notificationUrl", "vfModuleStackId").isEqualTo(reqMapper1);
}
@Test
package org.onap.so.client.adapter.vnf.mapper;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
mapper.addPairToMap(map, "test", "_key2", Arrays.asList());
- assertThat(map.containsKey("test_key2"), equalTo(false));
+ assertThat(map.containsKey("test_key2")).isFalse();
mapper.addPairToMap(map, "test", "_key3", "myVal");
DeleteVfModuleRequest actualDeleteVfModuleRequest =
mapper.deleteVfModuleRequestMapper(requestContext, cloudRegion, serviceInstance, genericVnf, vfModule);
- assertThat(actualDeleteVfModuleRequest,
- sameBeanAs(expectedDeleteVfModuleRequest).ignoring("messageId").ignoring("notificationUrl"));
+ assertThat(actualDeleteVfModuleRequest).usingRecursiveComparison()
+ .ignoringFields("messageId", "notificationUrl").isEqualTo(expectedDeleteVfModuleRequest);
}
}
package org.onap.so.client.namingservice;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.ArrayList;
import java.util.List;
import org.junit.Test;
Element actual =
mapper.elementMapper(instanceGroupId, policyInstanceName, namingType, nfNamingCode, instanceGroupName);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
// Actual Deleteelement
Deleteelement actual = mapper.deleteElementMapper(instanceGroupId);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
// Actual NameGenRequest
NameGenRequest actual = mapper.nameGenRequestMapper(elements);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
// Actual NameGenDeleteRequest
NameGenDeleteRequest actual = mapper.nameGenDeleteRequestMapper(deleteElements);
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
}
package org.onap.so.client.namingservice;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.HashMap;
import org.junit.Test;
import org.onap.namingservice.model.Element;
namingRequestObject.setResourceNameValue(resourceName);
HashMap<String, String> actual = namingRequestObject.getNamingRequestObjectMap();
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
namingRequestObject.setServiceModelNameValue(serviceModelName);
HashMap<String, String> actual = namingRequestObject.getNamingRequestObjectMap();
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
}
package org.onap.so.client.orchestration;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
doReturn(MOCK_aaiResourcesClient).when(MOCK_injectionHelper).getAaiClient();
}
-
@Test
public void updateNetworkTest() {
if (oVpnBinding.isPresent()) {
VpnBinding vpnBinding = oVpnBinding.get();
- assertThat(aaiResultWrapper.asBean(VpnBinding.class).get(), sameBeanAs(vpnBinding));
+ assertThat(aaiResultWrapper.asBean(VpnBinding.class).get()).usingRecursiveComparison()
+ .isEqualTo(vpnBinding);
}
}
verify(MOCK_aaiResourcesClient, times(1)).get(any(AAIResourceUri.class));
if (oNetPolicy.isPresent()) {
org.onap.aai.domain.yang.NetworkPolicy networkPolicy = oNetPolicy.get();
- assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.NetworkPolicy.class).get(),
- sameBeanAs(networkPolicy));
+ assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.NetworkPolicy.class).get())
+ .usingRecursiveComparison().isEqualTo(networkPolicy);
}
}
verify(MOCK_aaiResourcesClient, times(1)).get(any(AAIPluralResourceUri.class));
if (oNetPolicies.isPresent()) {
org.onap.aai.domain.yang.NetworkPolicies networkPolicies = oNetPolicies.get();
- assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.NetworkPolicies.class).get(),
- sameBeanAs(networkPolicies));
+ assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.NetworkPolicies.class).get())
+ .usingRecursiveComparison().isEqualTo(networkPolicies);
}
}
if (oRtref.isPresent()) {
RouteTableReference rTref = oRtref.get();
- assertThat(aaiResultWrapper.asBean(RouteTableReference.class).get(), sameBeanAs(rTref));
+ assertThat(aaiResultWrapper.asBean(RouteTableReference.class).get()).usingRecursiveComparison()
+ .isEqualTo(rTref);
}
}
assertEquals(network.getNetworkId(), aaiL3Network.get().getNetworkId());
assertEquals(network.getNetworkName(), aaiL3Network.get().getNetworkName());
-
}
@Test
if (oSubnet.isPresent()) {
org.onap.aai.domain.yang.Subnet subnet = oSubnet.get();
- assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.Subnet.class).get(), sameBeanAs(subnet));
+ assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.Subnet.class).get()).usingRecursiveComparison()
+ .isEqualTo(subnet);
}
}
package org.onap.so.client.orchestration;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
.cloudRegion(cloudRegion.getCloudOwner(), cloudRegion.getLcpCloudRegionId()))));
}
-
@Test
public void checkVnfClosedLoopDisabledFlagTest() {
Optional<org.onap.aai.domain.yang.GenericVnf> vnf = Optional.of(new org.onap.aai.domain.yang.GenericVnf());
assertTrue(isVnfPserversLockedFlag);
}
-
@Test
public void checkNameInUseTrueTest() {
AAIPluralResourceUri vnfUri = AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnfs())
if (oVserver.isPresent()) {
org.onap.aai.domain.yang.Vserver vserver = oVserver.get();
- assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.Vserver.class).get(), sameBeanAs(vserver));
+ assertThat(aaiResultWrapper.asBean(org.onap.aai.domain.yang.Vserver.class).get()).usingRecursiveComparison()
+ .isEqualTo(vserver);
}
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.client.orchestration;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertNotNull;
import static org.mockito.ArgumentMatchers.isA;
import static org.mockito.Mockito.doReturn;
import org.onap.so.client.adapter.network.mapper.NetworkAdapterObjectMapper;
import org.onap.so.db.catalog.beans.OrchestrationStatus;
import org.onap.so.entity.MsoRequest;
-import com.shazam.shazamcrest.matcher.Matchers;
@RunWith(MockitoJUnitRunner.Silent.class)
verify(MOCK_networkAdapterObjectMapper, times(1)).createNetworkRequestMapper(requestContext, cloudRegion,
orchestrationContext, serviceInstance, l3Network, userInput, cloudRegionPo, customer);
- assertThat(expectedCreateNetworkResponse, Matchers.sameBeanAs(actualCreateNetwrokResponse));
+ assertThat(expectedCreateNetworkResponse).usingRecursiveComparison().isEqualTo(actualCreateNetwrokResponse);
}
@Test
isA(ServiceInstance.class), isA(L3Network.class), isA(Map.class), isA(String.class),
isA(CreateNetworkResponse.class));
- RollbackNetworkResponse actualRollbackCreateNetwrokResponse =
+ RollbackNetworkResponse actualRollbackCreateNetworkResponse =
(networkAdapterResources.rollbackCreateNetwork(requestContext, cloudRegion, orchestrationContext,
serviceInstance, l3Network, userInput, cloudRegionPo, createNetworkResponse)).get();
cloudRegion, orchestrationContext, serviceInstance, l3Network, userInput, cloudRegionPo,
createNetworkResponse);
- assertThat(expectedRollbackNetworkResponse, Matchers.sameBeanAs(actualRollbackCreateNetwrokResponse));
+ assertThat(expectedRollbackNetworkResponse).usingRecursiveComparison()
+ .isEqualTo(actualRollbackCreateNetworkResponse);
}
@Test
verify(MOCK_networkAdapterObjectMapper, times(1)).deleteNetworkRequestMapper(requestContext, cloudRegion,
serviceInstance, l3Network);
verify(MOCK_networkAdapterClient, times(1)).deleteNetwork(l3Network.getNetworkId(), deleteNetworkRequest);
- assertThat(expectedDeleteNetworkResponse, Matchers.sameBeanAs(actualDeleteNetworkResponse));
+ assertThat(expectedDeleteNetworkResponse).usingRecursiveComparison().isEqualTo(actualDeleteNetworkResponse);
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.client.orchestration;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import org.onap.so.client.adapter.vnf.VnfVolumeAdapterClientImpl;
import org.onap.so.client.adapter.vnf.mapper.VnfAdapterObjectMapper;
import org.onap.so.db.catalog.beans.OrchestrationStatus;
-import com.shazam.shazamcrest.matcher.Matchers;
@RunWith(MockitoJUnitRunner.Silent.class)
public class VnfAdapterVolumeGroupResourcesTest extends TestDataSetup {
verify(MOCK_vnfAdapterObjectMapper, times(1)).createVolumeGroupRequestMapper(requestContext, cloudRegion,
orchestrationContext, serviceInstance, genericVnf, volumeGroup, sdncVfModuleQueryResponse);
- assertThat(createVolumeGroupRequest, Matchers.sameBeanAs(actualCreateVolumeGroupResponse));
+ assertThat(createVolumeGroupRequest).usingRecursiveComparison().isEqualTo(actualCreateVolumeGroupResponse);
}
@Test
verify(MOCK_vnfAdapterObjectMapper, times(1)).deleteVolumeGroupRequestMapper(requestContext, cloudRegion,
serviceInstance, volumeGroup);
- assertThat(expectedDeleteVolumeGroupRequest, Matchers.sameBeanAs(actualDeleteVolumeGroupRequest));
+ assertThat(expectedDeleteVolumeGroupRequest).usingRecursiveComparison()
+ .isEqualTo(actualDeleteVolumeGroupRequest);
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.client.policy;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
String configJson = returnedPolicyConfigList[0].getConfig();
Config actual = client.getConfigFromStringJson(configJson);
- org.hamcrest.MatcherAssert.assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Config actual = client.getConfigWithPolicyName("policyName");
- org.hamcrest.MatcherAssert.assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
}
<artifactId>cxf-rt-rs-client</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>com.shazam</groupId>
- <artifactId>shazamcrest</artifactId>
- <version>0.11</version>
- <scope>test</scope>
- <exclusions>
- <exclusion>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </exclusion>
- <exclusion>
- <groupId>org.apache.commons</groupId>
- <artifactId>commons-lang3</artifactId>
- </exclusion>
- <exclusion>
- <groupId>com.vaadin.external.google</groupId>
- <artifactId>android-json</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
+
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-catalina</artifactId>
<groupId>org.apache.httpcomponents</groupId>
<artifactId>httpclient</artifactId>
</exclusion>
- <exclusion>
- <groupId>org.skyscreamer</groupId>
- <artifactId>jsonassert</artifactId>
- </exclusion>
<exclusion>
<groupId>xmlunit</groupId>
<artifactId>xmlunit</artifactId>
<artifactId>mockito-core</artifactId>
<scope>test</scope>
</dependency>
- <dependency>
- <groupId>com.shazam</groupId>
- <artifactId>shazamcrest</artifactId>
- <version>0.11</version>
- <scope>test</scope>
- <exclusions>
- <exclusion>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </exclusion>
- <exclusion>
- <groupId>org.apache.commons</groupId>
- <artifactId>commons-lang3</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
+
<dependency>
<groupId>org.onap.aai.schema-service</groupId>
<artifactId>aai-schema</artifactId>
<artifactId>junit-vintage-engine</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.skyscreamer</groupId>
+ <artifactId>jsonassert</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
</project>
import static com.github.tomakehurst.wiremock.client.WireMock.put;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
import static com.github.tomakehurst.wiremock.core.WireMockConfiguration.wireMockConfig;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
Relationship relationship = new Relationship();
relationship.setRelatedLink(uri.build().toString());
Relationship actual = client.buildRelationship(uri);
- assertThat("expect equal no label", actual, sameBeanAs(relationship));
+ assertThat(actual).as("expect equal no label").usingRecursiveComparison().isEqualTo(relationship);
relationship.setRelationshipLabel(AAIEdgeLabel.USES.toString());
actual = client.buildRelationship(uri, AAIEdgeLabel.USES);
- assertThat("expect equal has label", actual, sameBeanAs(relationship));
+ assertThat(actual).as("expect equal has label").usingRecursiveComparison().isEqualTo(relationship);
}
package org.onap.so.apihandler.filters;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
thrown.expect(DuplicateRequestIdException.class);
thrown.expectMessage("HTTP 400 Bad Request");
-
requestIdFilter.filter(mockContext);
}
-
@Test
public void filterTestInfraSkipRequestIdLookup() throws IOException {
String requestId = REQUEST_ID;
requestIdFilter.filter(mockContext);
}
-
@Test
public void createRequestErrorTest() throws IOException {
RequestError requestError = getRequestError();
String result = requestIdFilter.createRequestError(REQUEST_ID, "InfraActiveRequests");
RequestError resultingError = mapper.readValue(result, RequestError.class);
- assertThat(resultingError, sameBeanAs(requestError));
+ assertThat(resultingError).usingRecursiveComparison().isEqualTo(requestError);
}
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.apihandlerinfra;
+import static org.assertj.core.api.Assertions.assertThat;
import org.apache.http.HttpStatus;
import org.junit.Rule;
import org.junit.Test;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasProperty;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.startsWith;
-
public class ApiExceptionTest {
@Rule
throw testException;
}
-
@Test
public void testBPMNFailureException() throws ApiException {
List<String> testVariables = new LinkedList<>();
thrown.expectMessage(startsWith("Request Failed due to BPEL error with HTTP Status ="));
thrown.expect(hasProperty("httpResponseCode", is(HttpStatus.SC_NOT_FOUND)));
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
- thrown.expect(hasProperty("variables", sameBeanAs(testVariables)));
+ thrown.expect(hasProperty("variables", equalTo(testVariables)));
BPMNFailureException testException = new BPMNFailureException.Builder("Test Message", HttpStatus.SC_NOT_FOUND,
ErrorNumbers.SVC_BAD_PARAMETER).variables(testVariables).build();
throw testException;
}
-
@Test
public void testClientConnectionException() throws ApiException {
IOException ioException = new IOException();
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
thrown.expect(hasProperty("httpResponseCode", is(HttpStatus.SC_NOT_FOUND)));
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
- thrown.expect(hasProperty("cause", sameBeanAs(ioException)));
+ thrown.expect(hasProperty("cause", equalTo(ioException)));
ClientConnectionException testException =
new ClientConnectionException.Builder("test", HttpStatus.SC_NOT_FOUND, ErrorNumbers.SVC_BAD_PARAMETER)
.cause(ioException).build();
throw testException;
}
-
@Test
public void testDuplicateRequestException() throws ApiException {
ErrorLoggerInfo testLog =
thrown.expectMessage(startsWith("Error: Locked instance"));
thrown.expect(hasProperty("httpResponseCode", is(HttpStatus.SC_NOT_FOUND)));
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
- thrown.expect(hasProperty("errorLoggerInfo", sameBeanAs(testLog)));
+ thrown.expect(hasProperty("errorLoggerInfo", equalTo(testLog)));
DuplicateRequestException testException = new DuplicateRequestException.Builder("Test1", "Test2", "Test3",
"Test4", HttpStatus.SC_NOT_FOUND, ErrorNumbers.SVC_BAD_PARAMETER).errorInfo(testLog).build();
throw testException;
}
-
@Test
public void testValidateException() throws ApiException {
thrown.expect(ValidateException.class);
throw testException;
}
-
@Test
public void testVfModuleNotFoundException() throws ApiException {
thrown.expect(VfModuleNotFoundException.class);
throw testException;
}
-
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.apihandlerinfra;
+import static org.assertj.core.api.Assertions.assertThat;
import org.apache.http.HttpStatus;
import org.junit.Rule;
import org.junit.Test;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasProperty;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.startsWith;
-
public class ApiExceptionTest extends BaseTest {
@Rule
throw testException;
}
-
@Test
public void testBPMNFailureException() throws ApiException {
List<String> testVariables = new LinkedList<>();
thrown.expectMessage(startsWith("Request Failed due to BPEL error with HTTP Status ="));
thrown.expect(hasProperty("httpResponseCode", is(HttpStatus.SC_NOT_FOUND)));
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
- thrown.expect(hasProperty("variables", sameBeanAs(testVariables)));
+ thrown.expect(hasProperty("variables", equalTo(testVariables)));
BPMNFailureException testException = new BPMNFailureException.Builder("Test Message", HttpStatus.SC_NOT_FOUND,
ErrorNumbers.SVC_BAD_PARAMETER).variables(testVariables).build();
throw testException;
}
-
@Test
public void testClientConnectionException() throws ApiException {
IOException ioException = new IOException();
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
thrown.expect(hasProperty("httpResponseCode", is(HttpStatus.SC_NOT_FOUND)));
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
- thrown.expect(hasProperty("cause", sameBeanAs(ioException)));
+ thrown.expect(hasProperty("cause", equalTo(ioException)));
ClientConnectionException testException =
new ClientConnectionException.Builder("test", HttpStatus.SC_NOT_FOUND, ErrorNumbers.SVC_BAD_PARAMETER)
.cause(ioException).build();
throw testException;
}
-
@Test
public void testDuplicateRequestException() throws ApiException {
ErrorLoggerInfo testLog =
thrown.expectMessage(startsWith("Error: Locked instance"));
thrown.expect(hasProperty("httpResponseCode", is(HttpStatus.SC_NOT_FOUND)));
thrown.expect(hasProperty("messageID", is(ErrorNumbers.SVC_BAD_PARAMETER)));
- thrown.expect(hasProperty("errorLoggerInfo", sameBeanAs(testLog)));
+ thrown.expect(hasProperty("errorLoggerInfo", equalTo(testLog)));
DuplicateRequestException testException = new DuplicateRequestException.Builder("Test1", "Test2", "Test3",
"Test4", HttpStatus.SC_NOT_FOUND, ErrorNumbers.SVC_BAD_PARAMETER).errorInfo(testLog).build();
throw testException;
}
-
@Test
public void testValidateException() throws ApiException {
throw testException;
}
-
@Test
public void testVfModuleNotFoundException() throws ApiException {
thrown.expect(VfModuleNotFoundException.class);
throw testException;
}
-
}
package org.onap.so.apihandlerinfra;
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.equalToJson;
import static com.github.tomakehurst.wiremock.client.WireMock.get;
import static com.github.tomakehurst.wiremock.client.WireMock.post;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
private final String e2eServInstancesUri = "/onap/so/infra/e2eServiceInstances/";
-
@Before
public void init() throws JsonProcessingException {
wireMockServer.stubFor(post(urlPathEqualTo("/testOrchestrationUri")).willReturn(aResponse()
assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatusCode().value());
RequestError realResponse = mapper.readValue(response.getBody(), RequestError.class);
- assertThat(realResponse, sameBeanAs(expectedResponse));
+ assertThat(realResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), response.getStatusCode().value());
RequestError realResponse = mapper.readValue(response.getBody(), RequestError.class);
- assertThat(realResponse, sameBeanAs(expectedResponse));
+ assertThat(realResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
}
@Test
package org.onap.so.apihandlerinfra;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.anyString;
import java.net.URI;
import org.springframework.test.util.ReflectionTestUtils;
import org.springframework.web.client.RestTemplate;
-
@RunWith(SpringRunner.class)
@ContextConfiguration(classes = {GenericStringConverter.class, HealthCheckConverter.class},
initializers = {ConfigDataApplicationContextInitializer.class})
assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
HealthCheckResponse root;
root = (HealthCheckResponse) response.getEntity();
- assertThat(root, sameBeanAs(expected).ignoring("subsystems.uri").ignoring("subsystems.subsystem"));
+ assertThat(root).usingRecursiveComparison().ignoringFields("subsystems.uri", "subsystems.subsystem")
+ .isEqualTo(expected);
}
assertEquals(Response.Status.OK.getStatusCode(), response.getStatus());
HealthCheckResponse root;
root = (HealthCheckResponse) response.getEntity();
- assertThat(root, sameBeanAs(expected).ignoring("subsystems.uri").ignoring("subsystems.subsystem"));
+ assertThat(root).usingRecursiveComparison().ignoringFields("subsystems.uri", "subsystems.subsystem")
+ .isEqualTo(expected);
}
@Test
assertEquals(MediaType.APPLICATION_JSON, he.getHeaders().getContentType());
}
-
@Test
public void processResponseFromSubsystemTest() {
SubsystemHealthcheckResponse subSystemResponse = new SubsystemHealthcheckResponse();
package org.onap.so.apihandlerinfra;
-
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.get;
import static com.github.tomakehurst.wiremock.client.WireMock.post;
import static com.github.tomakehurst.wiremock.client.WireMock.urlMatching;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.onap.logging.filter.base.Constants.HttpHeaders.ONAP_PARTNER_NAME;
import static org.onap.logging.filter.base.Constants.HttpHeaders.ONAP_REQUEST_ID;
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
package org.onap.so.apihandlerinfra;
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.post;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.junit.Assert.assertEquals;
import static org.onap.logging.filter.base.Constants.HttpHeaders.ECOMP_REQUEST_ID;
import static org.onap.logging.filter.base.Constants.HttpHeaders.ONAP_PARTNER_NAME;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.tomakehurst.wiremock.http.Fault;
-
public class ManualTasksTest extends BaseTest {
private final String basePath = "/onap/so/infra/tasks/v1/";
ResponseEntity<String> response =
restTemplate.exchange(builder.toUriString(), HttpMethod.POST, entity, String.class);
-
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true);
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
TaskRequestReference realResponse = mapper.readValue(response.getBody(), TaskRequestReference.class);
-
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
- assertThat(realResponse, sameBeanAs(expectedResponse));
+ assertThat(realResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
}
@Test
RequestError realResponse = mapper.readValue(response.getBody(), RequestError.class);
assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatusCode().value());
- assertThat(realResponse, sameBeanAs(expectedResponse));
+ assertThat(realResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
}
@Test
RequestError realResponse = mapper.readValue(response.getBody(), RequestError.class);
assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatusCode().value());
- assertThat(realResponse, sameBeanAs(expectedResponse));
+ assertThat(realResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
}
@Test
ResponseEntity<String> response =
restTemplate.exchange(builder.toUriString(), HttpMethod.POST, entity, String.class);
-
ObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
RequestError realResponse = mapper.readValue(response.getBody(), RequestError.class);
assertEquals(Response.Status.BAD_GATEWAY.getStatusCode(), response.getStatusCode().value());
- assertThat(realResponse, sameBeanAs(expectedResponse));
+ assertThat(realResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
}
}
package org.onap.so.apihandlerinfra;
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.any;
import static com.github.tomakehurst.wiremock.client.WireMock.equalTo;
import static com.github.tomakehurst.wiremock.client.WireMock.post;
import static com.github.tomakehurst.wiremock.client.WireMock.urlMatching;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
restTemplate.exchange(builder.build().toUri(), HttpMethod.GET, entity, GetOrchestrationResponse.class);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(response.getBody(), sameBeanAs(testResponse).ignoring("request.startTime")
- .ignoring("request.finishTime").ignoring("request.requestStatus.timeStamp"));
+ assertThat(response.getBody()).usingRecursiveComparison()
+ .ignoringFields("request.startTime", "request.finishTime", "request.requestStatus.timeStamp")
+ .isEqualTo(testResponse);
assertNull(response.getBody().getRequest().getInstanceReferences().getRequestorId());
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
restTemplate.exchange(builder.build().toUri(), HttpMethod.GET, entity, GetOrchestrationResponse.class);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(response.getBody(), sameBeanAs(testResponse).ignoring("request.startTime")
- .ignoring("request.finishTime").ignoring("request.requestStatus.timeStamp"));
+ assertThat(response.getBody()).usingRecursiveComparison()
+ .ignoringFields("request.startTime", "request.finishTime", "request.requestStatus.timeStamp")
+ .isEqualTo(testResponse);
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
assertEquals("0", response.getHeaders().get("X-PatchVersion").get(0));
restTemplate.exchange(builder.toUriString(), HttpMethod.GET, entity, GetOrchestrationResponse.class);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(response.getBody(), sameBeanAs(testResponse).ignoring("request.startTime")
- .ignoring("request.finishTime").ignoring("request.requestStatus.timeStamp"));
+ assertThat(response.getBody()).usingRecursiveComparison()
+ .ignoringFields("request.startTime", "request.finishTime", "request.requestStatus.timeStamp")
+ .isEqualTo(testResponse);
}
@Test
System.out.println("Response :" + response.getBody().toString());
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(response.getBody(), sameBeanAs(testResponse).ignoring("request.startTime")
- .ignoring("request.finishTime").ignoring("request.requestStatus.timeStamp"));
+ assertThat(response.getBody()).usingRecursiveComparison()
+ .ignoringFields("request.startTime", "request.finishTime", "request.requestStatus.timeStamp")
+ .isEqualTo(testResponse);
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
assertEquals("0", response.getHeaders().get("X-PatchVersion").get(0));
ResponseEntity<GetOrchestrationListResponse> response = restTemplate.exchange(builder.toUriString(),
HttpMethod.GET, entity, GetOrchestrationListResponse.class);
- assertThat(response.getBody(), sameBeanAs(testResponse).ignoring("requestList.request.startTime")
- .ignoring("requestList.request.finishTime").ignoring("requestList.request.requestStatus.timeStamp"));
+ assertThat(response.getBody())
+ .usingRecursiveComparison().ignoringFields("requestList.request.startTime",
+ "requestList.request.finishTime", "requestList.request.requestStatus.timeStamp")
+ .isEqualTo(testResponse);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
assertEquals(requests.size(), response.getBody().getRequestList().size());
actualRequestError = mapper.readValue(response.getBody(), RequestError.class);
assertEquals(Response.Status.BAD_REQUEST.getStatusCode(), response.getStatusCode().value());
- assertThat(actualRequestError, sameBeanAs(expectedRequestError));
+ assertThat(actualRequestError).usingRecursiveComparison().isEqualTo(expectedRequestError);
}
@Test
actualRequestError = mapper.readValue(response.getBody(), RequestError.class);
assertEquals(Response.Status.NOT_FOUND.getStatusCode(), response.getStatusCode().value());
- assertThat(expectedRequestError, sameBeanAs(actualRequestError));
+ assertThat(expectedRequestError).usingRecursiveComparison().isEqualTo(actualRequestError);
}
@Test
mapper.readValue(new File("src/test/resources/OrchestrationRequest/RequestProcessingData.json"),
new TypeReference<List<org.onap.so.db.request.beans.RequestProcessingData>>() {});
actualProcessingData = orchReq.mapRequestProcessingData(processingData);
- assertThat(actualProcessingData, sameBeanAs(expectedDataList));
+ assertThat(actualProcessingData).usingRecursiveComparison().isEqualTo(expectedDataList);
}
@Test
package org.onap.so.apihandlerinfra;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.CoreMatchers.containsString;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
private static final String ROLLBACK_EXT_SYSTEM_ERROR_SOURCE = "SDNC";
private Timestamp startTime = new Timestamp(System.currentTimeMillis());
-
@Before
public void setup() {
iar = new InfraActiveRequests();
Request result = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v7");
- assertThat(result, sameBeanAs(expected));
+ assertThat(result).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request result = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v7");
- assertThat(result, sameBeanAs(expected));
+ assertThat(result).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request result = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v8");
- assertThat(result, sameBeanAs(expected));
+ assertThat(result).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setRequestScope(SERVICE);
expected.setStartTime(new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss").format(startTime) + " GMT");
-
expected.setWorkflowName(REQUEST_ACTION);
expected.setRequestType(REQUEST_ACTION);
Request result = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v8");
- assertThat(result, sameBeanAs(expected));
+ assertThat(result).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v7");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.STATUSDETAIL.toString(), "v7");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.STATUSDETAIL.toString(), "v8");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.SIMPLENOTASKINFO.toString(), "v7");
- assertThat(expected, sameBeanAs(actual));
+ assertThat(expected).usingRecursiveComparison().isEqualTo(actual);
}
@Test
includeCloudRequest = false;
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest, null, "v7");
- assertThat(expected, sameBeanAs(actual));
+ assertThat(expected).usingRecursiveComparison().isEqualTo(actual);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v7");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v7");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v7");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
Request actual = orchestrationRequests.mapInfraActiveRequestToRequest(iar, includeCloudRequest,
OrchestrationRequestFormat.DETAIL.toString(), "v7");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
public void requestStatusExtSystemErrorSourceTest() {
RequestStatus requestStatus = new RequestStatus();
requestStatus.setExtSystemErrorSource(EXT_SYSTEM_ERROR_SOURCE);
- assertThat(requestStatus.getExtSystemErrorSource(), is(equalTo(EXT_SYSTEM_ERROR_SOURCE)));
+ assertThat(requestStatus.getExtSystemErrorSource()).isEqualTo(EXT_SYSTEM_ERROR_SOURCE);
}
@Test
assertEquals(Status.ABORTED.toString(), result);
}
-
@Test
public void mapRequestStatusToRequestForFormatEmptyStringTest() {
iar.setRequestStatus(Status.ABORTED.toString());
package org.onap.so.apihandlerinfra;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.doReturn;
currentActiveRequestIARNull.setOriginalRequestId(RESUMED_REQUEST_ID);
}
-
@Test
public void createNewRecordCopyFromInfraActiveRequestTest() throws IOException, ApiException {
doNothing().when(requestHandler).setInstanceIdAndName(infraActiveRequest, currentActiveRequest);
.updateRequestorIdInRequestBody(infraActiveRequest, "yyyyyy");
InfraActiveRequests result = requestHandler.createNewRecordCopyFromInfraActiveRequest(infraActiveRequest,
CURRENT_REQUEST_ID, startTimeStamp, "VID", requestUri, "yyyyyy", RESUMED_REQUEST_ID);
- assertThat(currentActiveRequest, sameBeanAs(result));
+ assertThat(currentActiveRequest).usingRecursiveComparison().isEqualTo(result);
}
@Test
public void createNewRecordCopyFromInfraActiveRequestNullIARTest() throws ApiException {
InfraActiveRequests result = requestHandler.createNewRecordCopyFromInfraActiveRequest(null, CURRENT_REQUEST_ID,
startTimeStamp, "VID", requestUri, "xxxxxx", RESUMED_REQUEST_ID);
- assertThat(currentActiveRequestIARNull, sameBeanAs(result));
+ assertThat(currentActiveRequestIARNull).usingRecursiveComparison().isEqualTo(result);
}
@Test
expected.setServiceInstanceName(SERVICE_INSTANCE_NAME);
requestHandler.setInstanceIdAndName(infraActiveRequest, serviceRequest);
- assertThat(serviceRequest, sameBeanAs(expected));
+ assertThat(serviceRequest).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setServiceInstanceId(SERVICE_INSTANCE_ID);
requestHandler.setInstanceIdAndName(request, serviceRequest);
- assertThat(serviceRequest, sameBeanAs(expected));
+ assertThat(serviceRequest).usingRecursiveComparison().isEqualTo(expected);
}
@Test
InfraActiveRequests expected = new InfraActiveRequests();
requestHandler.setInstanceIdAndName(originalServiceRequest, serviceRequest);
- assertThat(serviceRequest, sameBeanAs(expected));
+ assertThat(serviceRequest).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setVnfName(VNF_NAME);
requestHandler.setInstanceIdAndName(vnfRequestOriginal, vnfRequest);
- assertThat(vnfRequest, sameBeanAs(expected));
+ assertThat(vnfRequest).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setVfModuleName(VFMODULE_NAME);
requestHandler.setInstanceIdAndName(vfModuleRequestOriginal, vfModuleRequest);
- assertThat(vfModuleRequest, sameBeanAs(expected));
+ assertThat(vfModuleRequest).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setNetworkName(NETWORK_NAME);
requestHandler.setInstanceIdAndName(networkRequestOriginal, networkRequest);
- assertThat(networkRequest, sameBeanAs(expected));
+ assertThat(networkRequest).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setVolumeGroupName(VOLUME_GROUP_NAME);
requestHandler.setInstanceIdAndName(volumeGroupRequestOriginal, volumeGroupRequest);
- assertThat(volumeGroupRequest, sameBeanAs(expected));
+ assertThat(volumeGroupRequest).usingRecursiveComparison().isEqualTo(expected);
}
@Test
*/
package org.onap.so.apihandlerinfra;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
private HashMap<String, String> instanceIdMap = new HashMap<>();
ModelInfo modelInfo;
-
@Before
public void setup() throws IOException {
// Setup general requestHandler mocks
any(Action.class))).thenReturn(requestBody);
RequestClientParameter result = resumeReq.setRequestClientParameter(lookupResult, version, infraActiveRequest,
currentActiveRequest, "pnfCorrelationId", aLaCarte, sir);
- assertThat(requestClientParameter, sameBeanAs(result));
+ assertThat(requestClientParameter).usingRecursiveComparison().isEqualTo(result);
}
@Test
doReturn(ModelType.vfModule).when(requestHandler).getModelType(action, modelInfo);
RequestClientParameter result = resumeReq.setRequestClientParameter(lookupResult, version,
infraActiveRequestVfModule, currentActiveRequest, "pnfCorrelationId", aLaCarte, sir);
- assertThat(requestClientParameterVfModule, sameBeanAs(result));
+ assertThat(requestClientParameterVfModule).usingRecursiveComparison().isEqualTo(result);
}
@Test
package org.onap.so.apihandlerinfra;
-
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.get;
import static com.github.tomakehurst.wiremock.client.WireMock.post;
import static com.github.tomakehurst.wiremock.client.WireMock.urlMatching;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathMatching;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
Service defaultService = new Service();
defaultService.setModelUUID("d88da85c-d9e8-4f73-b837-3a72a431622a");
-
wireMockServer.stubFor(post(urlPathEqualTo("/mso/async/services/WorkflowActionBB"))
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBodyFile("Camunda/TestResponse.json").withStatus(org.apache.http.HttpStatus.SC_OK)));
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBodyFile("Camunda/TestResponse.json").withStatus(org.apache.http.HttpStatus.SC_OK)));
-
wireMockServer.stubFor(get(urlMatching(".*/service/search/.*"))
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBody(mapper.writeValueAsString(defaultService)).withStatus(HttpStatus.SC_OK)));
Service defaultService = new Service();
defaultService.setModelUUID("d88da85c-d9e8-4f73-b837-3a72a431622a");
-
wireMockServer.stubFor(post(urlPathEqualTo("/mso/async/services/WorkflowActionBB")).willReturn(aResponse()
.withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBodyFile("Camunda/TestResponse.json").withStatus(org.apache.http.HttpStatus.SC_BAD_GATEWAY)));
-
wireMockServer.stubFor(get(urlMatching(".*/service/search/.*"))
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBody(mapper.writeValueAsString(defaultService)).withStatus(HttpStatus.SC_OK)));
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBody(mapper.writeValueAsString(defaultService)).withStatus(HttpStatus.SC_OK)));
-
wireMockServer.stubFor(get(urlMatching(
".*/serviceRecipe/search/findFirstByServiceModelUUIDAndAction?serviceModelUUID=d88da85c-d9e8-4f73-b837-3a72a431622a&action=activateInstance"))
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertTrue(response.getBody().contains("1882939"));
}
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBodyFile("Camunda/TestResponse.json").withStatus(org.apache.http.HttpStatus.SC_OK)));
-
wireMockServer.stubFor(get(urlMatching(
".*/vnfResourceCustomization/search/findByModelCustomizationUUID[?]MODEL_CUSTOMIZATION_UUID=68dc9a92-214c-11e7-93ae-92361f002671"))
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
.withBody(getWiremockResponseForCatalogdb("vnfResourceCustomizationsList_Response.json"))
.withStatus(org.apache.http.HttpStatus.SC_OK)));
-
wireMockServer.stubFor(
get(urlMatching(".*/vnfResourceCustomization/68dc9a92-214c-11e7-93ae-92361f002672/vnfResources"))
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertTrue(response.getBody().contains("1882939"));
}
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
.withBodyFile("Camunda/TestResponse.json").withStatus(org.apache.http.HttpStatus.SC_OK)));
-
wireMockServer.stubFor(get(urlMatching(".*/vnfRecipe/search/findFirstVnfRecipeByNfRoleAndAction"
+ "[?]nfRole=GR-API-DEFAULT&action=applyUpdatedConfig"))
.willReturn(aResponse().withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON)
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertTrue(response.getBody().contains("1882939"));
}
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertTrue(response.getBody().contains("1882939"));
}
.withBody(getWiremockResponseForCatalogdb("vfModulePCM_Response.json"))
.withStatus(org.apache.http.HttpStatus.SC_OK)));
-
wireMockServer.stubFor(
get(urlMatching(".*/vnfComponentsRecipe/search/findFirstVnfComponentsRecipeByVnfComponentTypeAndAction"
+ "[?]vnfComponentType=vfModule&action=createInstance"))
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ObjectMapper mapper = new ObjectMapper();
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
ResponseEntity<String> response =
sendRequest(inputStream("/VfModuleNoMatchingModelUUID.json"), uri, HttpMethod.DELETE, headers);
-
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ObjectMapper mapper = new ObjectMapper();
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertTrue(response.getBody().contains("1882939"));
}
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertTrue(response.getBody().contains("1882939"));
}
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
.withBody(getWiremockResponseForCatalogdb("networkRecipe_Response.json"))
.withStatus(org.apache.http.HttpStatus.SC_OK)));
-
// expected response
ServiceInstancesResponse expectedResponse = new ServiceInstancesResponse();
RequestReferences requestReferences = new RequestReferences();
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
mapper.readValue(inputStream("/LegacyMacroServiceInstance.json"), ServiceInstancesRequest.class);
requestHandlerUtils.mapToLegacyRequest(request.getRequestDetails());
System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(request));
- assertThat(request, sameBeanAs(expected));
+ assertThat(request).usingRecursiveComparison().isEqualTo(expected);
}
@Test
.withBody(getWiremockResponseForCatalogdb("vfModule_Response.json"))
.withStatus(org.apache.http.HttpStatus.SC_OK)));
-
wireMockServer.stubFor(get(urlMatching(
".*/vnfComponentsRecipe/search/findFirstVnfComponentsRecipeByVfModuleModelUUIDAndVnfComponentTypeAndAction"
+ "[?]vfModuleModelUUID=GR-API-DEFAULT&vnfComponentType=vfModule&action=scaleOut"))
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertTrue(response.getBody().contains("1882939"));
}
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
assertEquals(response.getHeaders().get(TRANSACTION_ID).get(0), "32807a28-1a14-4b88-b7b3-2950918aa76d");
}
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
ServiceInstancesResponse realResponse = mapper.readValue(response.getBody(), ServiceInstancesResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse).ignoring("requestReferences.requestId"));
+ assertThat(realResponse).usingRecursiveComparison().ignoringFields("requestReferences.requestId")
+ .isEqualTo(expectedResponse);
}
@Test
assertEquals(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode(), response.getStatusCode().value());
RequestError realResponse = mapper.readValue(response.getBody(), RequestError.class);
- assertThat(expectedResponse, sameBeanAs(realResponse));
+ assertThat(expectedResponse).usingRecursiveComparison().isEqualTo(realResponse);
}
}
package org.onap.so.apihandlerinfra;
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.get;
import static com.github.tomakehurst.wiremock.client.WireMock.post;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import java.util.ArrayList;
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
-
// then
assertEquals(Response.Status.ACCEPTED.getStatusCode(), response.getStatusCode().value());
TasksGetResponse realResponse = mapper.readValue(response.getBody(), TasksGetResponse.class);
- assertThat(realResponse, sameBeanAs(expectedResponse));
+ assertThat(realResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
assertEquals("0", response.getHeaders().get("X-PatchVersion").get(0));
package org.onap.so.apihandlerinfra;
+import static org.assertj.core.api.Assertions.assertThat;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.ArrayList;
import java.util.List;
import static com.github.tomakehurst.wiremock.client.WireMock.*;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertEquals;
WorkflowSpecifications realResponse = mapper.readValue(response.getBody(), WorkflowSpecifications.class);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(expectedResponse, sameBeanAs(realResponse));
+ assertThat(expectedResponse).usingRecursiveComparison().isEqualTo(realResponse);
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
assertEquals("0", response.getHeaders().get("X-PatchVersion").get(0));
userParameter6.setName("lcpCloudRegionId");
userParameter6.setPayloadLocation("cloudConfiguration");
-
List<ActivitySpecUserParameters> activitySpecUserParameters = new ArrayList<ActivitySpecUserParameters>();
ActivitySpecUserParameters activitySpecUserParameter1 = new ActivitySpecUserParameters();
activitySpecUserParameter3.setUserParameters(userParameter3);
activitySpecUserParameters.add(activitySpecUserParameter3);
-
ActivitySpecUserParameters activitySpecUserParameter4 = new ActivitySpecUserParameters();
activitySpecUserParameter4.setUserParameters(userParameter4);
activitySpecUserParameters.add(activitySpecUserParameter4);
String expectedResultJson = mapper.writeValueAsString(expectedResult);
JSONAssert.assertEquals(expectedResultJson, workflowSpecificationsJson, false);
- assertThat(expectedResult, sameBeanAs(workflowSpecifications).ignoring(WorkflowInputParameter.class));
+ assertThat(expectedResult).usingRecursiveComparison().ignoringFieldsOfTypes(WorkflowInputParameter.class)
+ .isEqualTo(workflowSpecifications);
}
@Test
WorkflowSpecifications realResponse = mapper.readValue(response.getBody(), WorkflowSpecifications.class);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(expectedResponse, sameBeanAs(realResponse));
+ assertThat(expectedResponse).usingRecursiveComparison().isEqualTo(realResponse);
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
assertEquals("0", response.getHeaders().get("X-PatchVersion").get(0));
WorkflowSpecifications realResponse = mapper.readValue(response.getBody(), WorkflowSpecifications.class);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(expectedResponse, sameBeanAs(realResponse));
+ assertThat(expectedResponse).usingRecursiveComparison().isEqualTo(realResponse);
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
assertEquals("0", response.getHeaders().get("X-PatchVersion").get(0));
WorkflowSpecifications realResponse = mapper.readValue(response.getBody(), WorkflowSpecifications.class);
assertEquals(Response.Status.OK.getStatusCode(), response.getStatusCode().value());
- assertThat(expectedResponse, sameBeanAs(realResponse));
+ assertThat(expectedResponse).usingRecursiveComparison().isEqualTo(realResponse);
assertEquals("application/json", response.getHeaders().get(HttpHeaders.CONTENT_TYPE).get(0));
assertEquals("0", response.getHeaders().get("X-MinorVersion").get(0));
assertEquals("0", response.getHeaders().get("X-PatchVersion").get(0));
package org.onap.so.apihandlerinfra.infra.rest;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.spy;
@Rule
public ExpectedException exceptionRule = ExpectedException.none();
-
@Mock
private AAIResourcesClient aaiResourcesClient;
@InjectMocks
private BpmnRequestBuilder reqBuilder = spy(BpmnRequestBuilder.class);
-
private ObjectMapper mapper = new ObjectMapper();
private GraphInventoryCommonObjectMapperProvider provider = new GraphInventoryCommonObjectMapperProvider();
expectedRequest.getRequestDetails().getModelInfo().setModelId(null); // bad getter/setter setting multiple
// fields
ServiceInstancesRequest actualRequest = reqBuilder.buildServiceDeleteRequest("serviceId");
- assertThat(actualRequest, sameBeanAs(expectedRequest));
+ assertThat(actualRequest).usingRecursiveComparison().isEqualTo(expectedRequest);
}
@Test
ServiceInstancesRequest expectedRequest =
mapper.readValue(new File(RESOURCE_PATH + "ExpectedVnfRequest.json"), ServiceInstancesRequest.class);
ServiceInstancesRequest actualRequest = reqBuilder.buildVnfDeleteRequest("vnfId");
- assertThat(actualRequest, sameBeanAs(expectedRequest));
+ assertThat(actualRequest).usingRecursiveComparison().isEqualTo(expectedRequest);
}
@Test
.readValue(new File(RESOURCE_PATH + "ExpectedVfModuleRequest.json"), ServiceInstancesRequest.class);
ServiceInstancesRequest actualRequest =
reqBuilder.buildVFModuleDeleteRequest("vnfId", "vfModuleId", ModelType.vfModule);
- assertThat(actualRequest, sameBeanAs(expectedRequest));
+ assertThat(actualRequest).usingRecursiveComparison().isEqualTo(expectedRequest);
}
@Test
ServiceInstancesRequest expectedRequest = mapper
.readValue(new File(RESOURCE_PATH + "ExpectedVolumeGroupRequest.json"), ServiceInstancesRequest.class);
ServiceInstancesRequest actualRequest = reqBuilder.buildVolumeGroupDeleteRequest("vnfId", "volumeGroupId");
- assertThat(actualRequest, sameBeanAs(expectedRequest));
+ assertThat(actualRequest).usingRecursiveComparison().isEqualTo(expectedRequest);
}
@Test
doReturn(filters).when(reqBuilder).createQueryRequest("vnfId", vnfId);
doReturn(Optional.of(serviceRequest)).when(reqBuilder).findServiceInstanceRequest(filters);
-
CloudConfiguration result = reqBuilder.mapCloudConfigurationVnf(vnfId);
assertEquals("tenantId", result.getTenantId());
assertEquals("cloudOwner", result.getCloudOwner());
package org.onap.so.apihandlerinfra.infra.rest.handler;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doReturn;
import java.net.MalformedURLException;
import java.net.URL;
doReturn(Optional.of(selfLinkURL)).when(restHandler).buildSelfLinkUrl("http://localhost:8080/v1", "requestId");
ServiceInstancesResponse actualResponse =
restHandler.createResponse("instanceId", "requestId", mockRequestContext);
- assertThat(actualResponse, sameBeanAs(expectedResponse));
+ assertThat(actualResponse).usingRecursiveComparison().isEqualTo(expectedResponse);
}
@Test
"http://some.domain.com:30277/onap/so/infra/orchestrationRequests/v7/4d0437c3-ee48-4361-a4f7-e1613c82493a"));
Optional<URL> resultURL = restHandler.buildSelfLinkUrl(initialLink, requestId);
- assertThat(resultURL, sameBeanAs(expectedLink));
+ assertThat(resultURL).usingRecursiveComparison().isEqualTo(expectedLink);
}
}
package org.onap.so.apihandlerinfra.infra.rest.handler;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
import java.util.HashMap;
.setRequestUri("http://localhost:8080/serviceInstances").setApiVersion("v8").build();
RequestClientParameter actual = restHandler.buildRequestParams(createTestRequest(),
"http://localhost:8080/serviceInstances", "requestId", "serviceInstanceId", "networkId");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setRequestUrl("http://localhost:9090");
InfraActiveRequests actual = restHandler.createInfraActiveRequestForDelete("requestId", "serviceInstanceId",
"networkId", "userId", "VID", "http://localhost:9090");
- assertThat(actual, sameBeanAs(expected).ignoring("startTime"));
+ assertThat(actual).usingRecursiveComparison().ignoringFields("startTime").isEqualTo(expected);
Mockito.verify(infraActiveRequestsClient, Mockito.times(1)).save(actual);
}
package org.onap.so.apihandlerinfra.infra.rest.handler;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
doReturn(expected).when(catalogDbClient)
.findServiceRecipeByActionAndServiceModelUUID(Action.createInstance.toString(), "testModelId");
Recipe actual = restHandler.findServiceRecipe("testModelId", Action.createInstance.toString());
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
Mockito.verify(catalogDbClient, Mockito.times(1))
.findServiceRecipeByActionAndServiceModelUUID(Action.createInstance.toString(), "testModelId");
}
doReturn(expected).when(catalogDbClient).findServiceRecipeByActionAndServiceModelUUID(
Action.createInstance.toString(), "d88da85c-d9e8-4f73-b837-3a72a431622b");
Recipe actual = restHandler.findServiceRecipe("testModelId", Action.createInstance.toString());
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
Mockito.verify(catalogDbClient, Mockito.times(1))
.findServiceRecipeByActionAndServiceModelUUID(Action.createInstance.toString(), "testModelId");
Mockito.verify(catalogDbClient, Mockito.times(1)).findServiceRecipeByActionAndServiceModelUUID(
.setRequestUri("http://localhost:8080/serviceInstances").setApiVersion("v8").build();
RequestClientParameter actual = restHandler.buildRequestParams(createTestRequest(),
"http://localhost:8080/serviceInstances", "requestId", "serviceInstanceId");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setRequestScope(ModelType.service.toString());
InfraActiveRequests actual = restHandler.createInfraActiveRequestForDelete("requestId", "serviceInstanceId",
"userId", "VID", "http://localhost:9090");
- assertThat(actual, sameBeanAs(expected).ignoring("startTime"));
+ assertThat(actual).usingRecursiveComparison().ignoringFields("startTime").isEqualTo(expected);
Mockito.verify(infraActiveRequestsClient, Mockito.times(1)).save(actual);
}
package org.onap.so.apihandlerinfra.infra.rest.handler;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doReturn;
ModelType.vfModule.toString(), Action.createInstance.toString());
Recipe actual = restHandler.findVfModuleRecipe("testModelId", ModelType.vfModule.toString(),
Action.createInstance.toString());
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
Mockito.verify(catalogDbClient, Mockito.times(1))
.getFirstVnfComponentsRecipeByVfModuleModelUUIDAndVnfComponentTypeAndAction("testModelId",
ModelType.vfModule.toString(), Action.createInstance.toString());
ModelType.vfModule.toString(), Action.createInstance.toString());
Recipe actual = restHandler.findVfModuleRecipe("testModelId", ModelType.vfModule.toString(),
Action.createInstance.toString());
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
Mockito.verify(catalogDbClient, Mockito.times(1))
.getFirstVnfComponentsRecipeByVfModuleModelUUIDAndVnfComponentTypeAndAction("testModelId",
ModelType.vfModule.toString(), Action.createInstance.toString());
.setRequestUri("http://localhost:8080/serviceInstances").setApiVersion("v8").build();
RequestClientParameter actual = restHandler.buildRequestParams(createTestRequest(),
"http://localhost:8080/serviceInstances", "requestId", "serviceInstanceId", "vnfId", "vfModuleId");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setRequestScope(ModelType.vfModule.toString());
InfraActiveRequests actual = restHandler.createInfraActiveRequestForDelete("requestId", "vfModuleId",
"serviceInstanceId", "vnfId", "userId", "VID", "http://localhost:9090");
- assertThat(actual, sameBeanAs(expected).ignoring("startTime"));
+ assertThat(actual).usingRecursiveComparison().ignoringFields("startTime").isEqualTo(expected);
Mockito.verify(infraActiveRequestsClient, Mockito.times(1)).save(actual);
}
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
package org.onap.so.apihandlerinfra.infra.rest.handler;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
import java.util.HashMap;
import org.onap.so.apihandlerinfra.Constants;
import org.onap.so.constants.Status;
import org.onap.so.db.catalog.beans.Recipe;
-import org.onap.so.db.catalog.beans.ServiceRecipe;
import org.onap.so.db.catalog.client.CatalogDbClient;
import org.onap.so.db.request.beans.InfraActiveRequests;
import org.onap.so.db.request.client.RequestsDbClient;
@Test
public void test_find_vnf_recipe() {
- ServiceRecipe expected = new ServiceRecipe();
- expected.setOrchestrationUri("/mso/async/services/WorkflowActionBB");
Recipe actual = restHandler.findVnfModuleRecipe("testModelId", ModelType.vnf.toString(),
Action.createInstance.toString());
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual.getOrchestrationUri()).isEqualTo("/mso/async/services/WorkflowActionBB");
}
@Test
.setRequestUri("http://localhost:8080/serviceInstances").setApiVersion("v8").build();
RequestClientParameter actual = restHandler.buildRequestParams(createTestRequest(),
"http://localhost:8080/serviceInstances", "requestId", "serviceInstanceId", "vnfId");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setRequestScope(ModelType.vnf.toString());
InfraActiveRequests actual = restHandler.createInfraActiveRequestForDelete("requestId", "serviceInstanceId",
"vnfId", "userId", "VID", "http://localhost:9090");
- assertThat(actual, sameBeanAs(expected).ignoring("startTime"));
+ assertThat(actual).usingRecursiveComparison().ignoringFields("startTime").isEqualTo(expected);
Mockito.verify(infraActiveRequestsClient, Mockito.times(1)).save(actual);
}
package org.onap.so.apihandlerinfra.infra.rest.handler;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.eq;
import java.util.HashMap;
.setRequestUri("http://localhost:8080/serviceInstances").setApiVersion("v8").build();
RequestClientParameter actual = restHandler.buildRequestParams(createTestRequest(),
"http://localhost:8080/serviceInstances", "requestId", "serviceInstanceId", "vnfId", "volumeGroupId");
- assertThat(actual, sameBeanAs(expected));
+ assertThat(actual).usingRecursiveComparison().isEqualTo(expected);
}
@Test
expected.setRequestUrl("http://localhost:9090");
InfraActiveRequests actual = restHandler.createInfraActiveRequestForDelete("requestId", "volumeGroupId",
"serviceInstanceId", "vnfId", "userId", "VID", "http://localhost:9090");
- assertThat(actual, sameBeanAs(expected).ignoring("startTime"));
+ assertThat(actual).usingRecursiveComparison().ignoringFields("startTime").isEqualTo(expected);
Mockito.verify(infraActiveRequestsClient, Mockito.times(1)).save(actual);
}
package org.onap.so.apihandlerinfra.tenantisolation.helpers;
+import static org.assertj.core.api.Assertions.assertThat;
import org.junit.Before;
import org.junit.Test;
import org.onap.so.apihandlerinfra.BaseTest;
import org.onap.so.db.request.beans.OperationalEnvDistributionStatus;
import org.onap.so.db.request.beans.OperationalEnvServiceModelStatus;
import org.springframework.beans.factory.annotation.Autowired;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
-import static org.hamcrest.MatcherAssert.assertThat;
-
public class ActivateVnfDBHelperTest extends BaseTest {
// test insert method
OperationalEnvDistributionStatus distStatus1 = dbHelper.insertRecordToOperationalEnvDistributionStatus(
distributionId1, operationalEnvironmentId, serviceModelVersionId1, requestId, statusOk, "");
- assertThat(distStatus1, sameBeanAs(expectedDistStatus));
+ assertThat(distStatus1).usingRecursiveComparison().isEqualTo(expectedDistStatus);
// prepare updated expected object
OperationalEnvDistributionStatus expectedUpdatedDistStatus = expectedDistStatus;
// test update method - statusOk to statusError
OperationalEnvDistributionStatus distStatus2 =
dbHelper.updateStatusInOperationalEnvDistributionStatus(distStatus1, statusError, errorReason);
- assertThat(distStatus2, sameBeanAs(expectedUpdatedDistStatus));
+ assertThat(distStatus2).usingRecursiveComparison().isEqualTo(expectedUpdatedDistStatus);
}
OperationalEnvServiceModelStatus serviceModelStatus1 = dbHelper.insertRecordToOperationalEnvServiceModelStatus(
requestId, operationalEnvironmentId, serviceModelVersionId1, statusOk, recoveryActionRetry,
retryCountThree, workloadContext1, vnfOperationalEnvironmentId);
- assertThat(serviceModelStatus1, sameBeanAs(expectedServiceModelStatus));
+ assertThat(serviceModelStatus1).usingRecursiveComparison().isEqualTo(expectedServiceModelStatus);
// prepare updated expected object
OperationalEnvServiceModelStatus expectedUpdatedServiceModelStatus = serviceModelStatus1;
OperationalEnvServiceModelStatus serviceModelStatus2 =
dbHelper.updateRetryCountAndStatusInOperationalEnvServiceModelStatus(serviceModelStatus1, statusError,
retryCountZero);
- assertThat(serviceModelStatus2, sameBeanAs(expectedUpdatedServiceModelStatus));
+ assertThat(serviceModelStatus2).usingRecursiveComparison().isEqualTo(expectedUpdatedServiceModelStatus);
}
package org.onap.so.apihandlerinfra.tenantisolation.process;
+import static org.assertj.core.api.Assertions.assertThat;
import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
import static com.github.tomakehurst.wiremock.client.WireMock.containing;
import static com.github.tomakehurst.wiremock.client.WireMock.get;
import static com.github.tomakehurst.wiremock.client.WireMock.put;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathEqualTo;
import static com.github.tomakehurst.wiremock.client.WireMock.urlPathMatching;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
import java.util.UUID;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
-
public class CreateEcompOperationalEnvironmentTest extends BaseTest {
@Autowired
try {
createEcompOpEn.execute(uuid, getCloudOrchestrationRequest());
} catch (ApiException e) {
- assertThat(e, sameBeanAs((ApiException) expectedException).ignoring("cause"));
+ assertThat(e).usingRecursiveComparison().ignoringFields("cause")
+ .isEqualTo((ApiException) expectedException);
}
}
package org.onap.so.db.catalog.data.repository;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.ArrayList;
import java.util.List;
import org.junit.Assert;
@Autowired
private CvnfcCustomizationRepository cvnfcCustomizationRepository;
-
@Test
public void findAllTest() {
List<CvnfcCustomization> cvnfcCustomizationList = cvnfcCustomizationRepository.findAll();
vnfResourceCustomizations.add(vnfResourceCustomization);
vnfResourceCustomization.setVnfResources(vnfResource);
-
VnfcCustomization vnfcCustomization = setUpVnfcCustomization();
vnfcCustomization.setModelCustomizationUUID("d95d704a-9ff2-11e8-98d0-529269fb1459");
for (CvnfcCustomization foundCvnfcCustomization : cvnfcCustomizationList) {
if (foundCvnfcCustomization.getDescription().equalsIgnoreCase(cvnfcCustomization.getDescription())) {
- assertThat(cvnfcCustomization,
- sameBeanAs(foundCvnfcCustomization).ignoring("id").ignoring("created")
- .ignoring("vnfVfmoduleCvnfcConfigurationCustomization")
- .ignoring("vnfResourceCusteModelCustomizationUUID"));
+ assertThat(cvnfcCustomization)
+ .usingRecursiveComparison().ignoringFields("id", "created",
+ "vnfVfmoduleCvnfcConfigurationCustomization", "vnfResourceCusteModelCustomizationUUID")
+ .isEqualTo(foundCvnfcCustomization);
matchFound = true;
break;
vnfResourceCustomizations.add(vnfResourceCustomization);
vnfResourceCustomization.setVnfResources(vnfResource);
-
VnfcCustomization vnfcCustomization = setUpVnfcCustomization();
vnfcCustomization.setModelCustomizationUUID("d95d704a-9ff2-11e8-98d0-529269fb1459");
cvnfcCustomizationRepository.save(cvnfcCustomization);
-
List<CvnfcCustomization> cvnfcCustomizationList =
cvnfcCustomizationRepository.findByModelCustomizationUUID("cf9f6efc-9f14-11e8-98d0-529269fb1459");
boolean matchFound = false;
for (CvnfcCustomization foundCvnfcCustomization : cvnfcCustomizationList) {
if (foundCvnfcCustomization.getDescription().equalsIgnoreCase(cvnfcCustomization.getDescription())) {
- assertThat(cvnfcCustomization,
- sameBeanAs(foundCvnfcCustomization).ignoring("id").ignoring("created")
- .ignoring("vnfVfmoduleCvnfcConfigurationCustomization")
- .ignoring("vnfResourceCusteModelCustomizationUUID"));
+ assertThat(cvnfcCustomization)
+ .usingRecursiveComparison().ignoringFields("id", "created",
+ "vnfVfmoduleCvnfcConfigurationCustomization", "vnfResourceCusteModelCustomizationUUID")
+ .isEqualTo(foundCvnfcCustomization);
matchFound = true;
break;
Assert.assertTrue(matchFound);
}
-
@Test
@Transactional
public void createAndGetCvnfcCustomizationTest() {
vnfResourceCustomizations.add(vnfResourceCustomization);
vnfResourceCustomization.setVnfResources(vnfResource);
-
-
VnfcCustomization vnfcCustomization = setUpVnfcCustomization();
vnfcCustomization.setModelCustomizationUUID("d95d704a-9ff2-11e8-98d0-529269fb1459");
CvnfcCustomization cvnfcCustomizationList =
cvnfcCustomizationRepository.findOneByModelCustomizationUUID("cf9f6efc-9f14-11e8-98d0-529269fb1459");
- assertThat(cvnfcCustomization,
- sameBeanAs(cvnfcCustomizationList).ignoring("id").ignoring("created")
- .ignoring("vnfVfmoduleCvnfcConfigurationCustomization")
- .ignoring("vnfResourceCusteModelCustomizationUUID"));
+ assertThat(cvnfcCustomization)
+ .usingRecursiveComparison().ignoringFields("id", "created",
+ "vnfVfmoduleCvnfcConfigurationCustomization", "vnfResourceCusteModelCustomizationUUID")
+ .isEqualTo(cvnfcCustomizationList);
}
-
-
}
package org.onap.so.db.catalog.data.repository;
-import static com.shazam.shazamcrest.MatcherAssert.assertThat;
-import static com.shazam.shazamcrest.matcher.Matchers.sameBeanAs;
+import static org.assertj.core.api.Assertions.assertThat;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
vnfcCustomizationRepository.findById("cf9f6efc-9f14-11e8-98d0-529269fb1459")
.orElseThrow(() -> new NoEntityFoundException("Cannot Find Operation"));
- assertThat(vnfcCustomization, sameBeanAs(foundVnfcCustomization).ignoring("created"));
+ assertThat(vnfcCustomization).usingRecursiveComparison().ignoringFields("created")
+ .isEqualTo(foundVnfcCustomization);
}
}
<artifactId>openpojo</artifactId>
<version>0.8.13</version>
</dependency>
- <dependency>
- <groupId>com.shazam</groupId>
- <artifactId>shazamcrest</artifactId>
- <version>0.11</version>
- <scope>test</scope>
- <exclusions>
- <exclusion>
- <groupId>com.google.guava</groupId>
- <artifactId>guava</artifactId>
- </exclusion>
- <exclusion>
- <groupId>org.apache.commons</groupId>
- <artifactId>commons-lang3</artifactId>
- </exclusion>
- <exclusion>
- <groupId>com.vaadin.external.google</groupId>
- <artifactId>android-json</artifactId>
- </exclusion>
- </exclusions>
- </dependency>
+
<dependency>
<groupId>org.assertj</groupId>
<artifactId>assertj-core</artifactId>
- <version>3.11.1</version>
+ <version>3.16.0</version>
<scope>test</scope>
</dependency>
<dependency>
Code Review / so.git / commitdiff