diff options
Diffstat (limited to 'catalog-be/src/test/java/org/openecomp/sdc/be/components')
6 files changed, 135 insertions, 127 deletions
diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CapabilityTypeImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CapabilityTypeImportManagerTest.java index f8b1800951..a4d02e146c 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CapabilityTypeImportManagerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CapabilityTypeImportManagerTest.java @@ -7,9 +7,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -20,7 +20,19 @@ package org.openecomp.sdc.be.components.impl; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + import fj.data.Either; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.HashMap; +import java.util.List; +import java.util.Map; import java.util.Optional; import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.Before; @@ -41,37 +53,26 @@ import org.openecomp.sdc.be.model.operations.impl.PropertyOperation; import org.openecomp.sdc.common.util.CapabilityTypeNameEnum; import org.openecomp.sdc.exception.ResponseFormat; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; - public class CapabilityTypeImportManagerTest { + private static final CapabilityTypeOperation capabilityTypeOperation = mock(CapabilityTypeOperation.class); private static final ComponentsUtils componentsUtils = mock(ComponentsUtils.class); private static final JanusGraphGenericDao JANUS_GRAPH_GENERIC_DAO = mock(JanusGraphGenericDao.class); private static final PropertyOperation propertyOperation = mock(PropertyOperation.class); - private CommonImportManager commonImportManager = new CommonImportManager(componentsUtils, propertyOperation); - private ModelOperation modelOperation = mock(ModelOperation.class); + private static final ModelOperation modelOperation = mock(ModelOperation.class); + private CommonImportManager commonImportManager = new CommonImportManager(componentsUtils, propertyOperation, modelOperation); private CapabilityTypeImportManager manager = new CapabilityTypeImportManager(capabilityTypeOperation, commonImportManager, modelOperation); @BeforeClass public static void beforeClass() { - when(capabilityTypeOperation.addCapabilityType(Mockito.any(CapabilityTypeDefinition.class))).thenAnswer(new Answer<Either<CapabilityTypeDefinition, StorageOperationStatus>>() { - public Either<CapabilityTypeDefinition, StorageOperationStatus> answer(InvocationOnMock invocation) { - Object[] args = invocation.getArguments(); - return Either.left((CapabilityTypeDefinition) args[0]); - } + when(capabilityTypeOperation.addCapabilityType(Mockito.any(CapabilityTypeDefinition.class))).thenAnswer( + new Answer<Either<CapabilityTypeDefinition, StorageOperationStatus>>() { + public Either<CapabilityTypeDefinition, StorageOperationStatus> answer(InvocationOnMock invocation) { + Object[] args = invocation.getArguments(); + return Either.left((CapabilityTypeDefinition) args[0]); + } - }); + }); when(propertyOperation.getJanusGraphGenericDao()).thenReturn(JANUS_GRAPH_GENERIC_DAO); when(capabilityTypeOperation.getCapabilityType(Mockito.anyString())).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); @@ -86,7 +87,8 @@ public class CapabilityTypeImportManagerTest { public void testCreateCapabilityTypes() throws IOException { String ymlContent = getCapabilityTypesYml(); when(modelOperation.findModelByName("testModel")).thenReturn(Optional.of(new Model("testModel"))); - Either<List<ImmutablePair<CapabilityTypeDefinition, Boolean>>, ResponseFormat> createCapabilityTypes = manager.createCapabilityTypes(ymlContent, "testModel"); + Either<List<ImmutablePair<CapabilityTypeDefinition, Boolean>>, ResponseFormat> createCapabilityTypes = manager.createCapabilityTypes( + ymlContent, "testModel", false); assertTrue(createCapabilityTypes.isLeft()); List<ImmutablePair<CapabilityTypeDefinition, Boolean>> capabilityTypesList = createCapabilityTypes.left().value(); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java index 0527f372d4..b360a94862 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/CommonImportManagerTest.java @@ -7,9 +7,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -20,7 +20,17 @@ package org.openecomp.sdc.be.components.impl; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + import fj.data.Either; +import java.util.Arrays; +import java.util.List; +import java.util.function.BiFunction; +import java.util.function.Function; import org.apache.commons.lang3.tuple.ImmutablePair; import org.junit.Before; import org.junit.Test; @@ -34,31 +44,24 @@ import org.openecomp.sdc.be.dao.janusgraph.JanusGraphGenericDao; import org.openecomp.sdc.be.impl.ComponentsUtils; import org.openecomp.sdc.be.model.CapabilityTypeDefinition; import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; +import org.openecomp.sdc.be.model.operations.impl.ModelOperation; import org.openecomp.sdc.be.model.operations.impl.PropertyOperation; import org.openecomp.sdc.exception.ResponseFormat; import org.openecomp.sdc.exception.ServiceException; -import java.util.Arrays; -import java.util.List; -import java.util.function.BiFunction; -import java.util.function.Function; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - @RunWith(MockitoJUnitRunner.class) public class CommonImportManagerTest { + private CommonImportManager commonImportManager; @Mock private ComponentsUtils componentsUtils; @Mock - PropertyOperation propertyOperation; + private PropertyOperation propertyOperation; + @Mock + private ModelOperation modelOperation; @Mock private JanusGraphGenericDao janusGraphGenericDao; - + @Mock private Function<Object, Either<ActionStatus, ResponseFormat>> validator; @Mock @@ -69,59 +72,60 @@ public class CommonImportManagerTest { private Function<Object, Either<Object, StorageOperationStatus>> elementAdder; @Mock private BiFunction<Object, Object, Either<Object, StorageOperationStatus>> elementUpgrader; - + @Before public void startUp() { - commonImportManager = new CommonImportManager(componentsUtils, propertyOperation); - + commonImportManager = new CommonImportManager(componentsUtils, propertyOperation, modelOperation); + when(propertyOperation.getJanusGraphGenericDao()).thenReturn(janusGraphGenericDao); } - + @Test public void testCreateElementTypesByDao_validationFailed() { Object type1 = new Object(); List<Object> elementTypesToCreate = Arrays.asList(type1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1)).thenReturn(elementInfo); - + ResponseFormat responseFormat = new ResponseFormat(); responseFormat.setServiceException(new ServiceException()); when(validator.apply(type1)).thenReturn(Either.right(responseFormat)); + Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate, + validator, elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); - Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); - verify(elementAdder, never()).apply(Mockito.any()); verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any()); verify(janusGraphGenericDao).rollback(); assertThat(result.isRight()).isTrue(); } - + @Test(expected = RuntimeException.class) public void testCreateElementTypesByDao_RuntTimeExceptionInValidation() { Object type1 = new Object(); List<Object> elementTypesToCreate = Arrays.asList(type1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1)).thenReturn(elementInfo); when(validator.apply(type1)).thenThrow(new RuntimeException("Test Exception")); - - commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); - + + commonImportManager.createElementTypesByDao(elementTypesToCreate, validator, elementInfoGetter, elementFetcher, elementAdder, + elementUpgrader); + verify(elementAdder, never()).apply(Mockito.any()); verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any()); verify(janusGraphGenericDao).rollback(); } - + @Test public void testCreateElementTypesByDao_capabilityTypeFetcherFailed() { CapabilityTypeDefinition type1 = new CapabilityTypeDefinition(); List<Object> elementTypesToCreate = Arrays.asList(type1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1)).thenReturn(elementInfo); - + when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK)); when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.BAD_REQUEST)); ResponseFormat responseFormat = new ResponseFormat(); @@ -129,34 +133,34 @@ public class CommonImportManagerTest { when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod(); when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.INVALID_CONTENT, type1)).thenReturn(responseFormat); + Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate, + validator, elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); - Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); - verify(elementAdder, never()).apply(Mockito.any()); verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any()); verify(janusGraphGenericDao).rollback(); assertThat(result.isRight()).isTrue(); } - + @Test public void testCreateElementTypesByDao_capabilityTypeNotFound_AddFailed() { CapabilityTypeDefinition type1 = new CapabilityTypeDefinition(); List<Object> elementTypesToCreate = Arrays.asList(type1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1)).thenReturn(elementInfo); - + when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK)); when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); when(elementAdder.apply(type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION)); - + ResponseFormat responseFormat = new ResponseFormat(); responseFormat.setServiceException(new ServiceException()); when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod(); when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1)).thenReturn(responseFormat); - - Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); + Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate, + validator, elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); verify(elementAdder).apply(type1); verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any()); @@ -164,99 +168,101 @@ public class CommonImportManagerTest { assertThat(result.isRight()).isTrue(); } - + @Test public void testCreateElementTypesByDao_capabilityTypeNotFound_AddSucceeded() { CapabilityTypeDefinition type1 = new CapabilityTypeDefinition(); List<Object> elementTypesToCreate = Arrays.asList(type1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1)).thenReturn(elementInfo); - + when(validator.apply(type1)).thenReturn(Either.left(ActionStatus.OK)); when(elementFetcher.apply("TestCapability")).thenReturn(Either.right(StorageOperationStatus.NOT_FOUND)); when(elementAdder.apply(type1)).thenReturn(Either.left(type1)); - - - Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); + + Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate, + validator, elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); verify(elementAdder).apply(type1); verify(elementUpgrader, never()).apply(Mockito.any(), Mockito.any()); verify(janusGraphGenericDao).commit(); - + assertEquals(type1, result.left().value().get(0).getLeft()); assertEquals(true, result.left().value().get(0).getRight()); } - + @Test public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeFailed() { CapabilityTypeDefinition type1 = new CapabilityTypeDefinition(); CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition(); List<Object> elementTypesToCreate = Arrays.asList(type1_1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo); - + when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK)); when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1)); when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.SCHEMA_VIOLATION)); - + ResponseFormat responseFormat = new ResponseFormat(); responseFormat.setServiceException(new ServiceException()); when(componentsUtils.convertFromStorageResponseForCapabilityType(Mockito.any())).thenCallRealMethod(); when(componentsUtils.getResponseFormatByCapabilityType(ActionStatus.CAPABILITY_TYPE_ALREADY_EXIST, type1_1)).thenReturn(responseFormat); - - Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); + Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate, + validator, elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); verify(elementAdder, never()).apply(Mockito.any()); verify(elementUpgrader).apply(type1_1, type1); verify(janusGraphGenericDao).rollback(); assertThat(result.isRight()).isTrue(); } - + @Test public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeSucceeded() { CapabilityTypeDefinition type1 = new CapabilityTypeDefinition(); CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition(); List<Object> elementTypesToCreate = Arrays.asList(type1_1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo); - + when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK)); when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1)); when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.left(type1_1)); - - Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); + + Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate, + validator, elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); verify(elementAdder, never()).apply(Mockito.any()); verify(elementUpgrader).apply(type1_1, type1); verify(janusGraphGenericDao).commit(); - + assertEquals(type1_1, result.left().value().get(0).getLeft()); assertEquals(true, result.left().value().get(0).getRight()); } - + @Test public void testCreateElementTypesByDao_capabilityTypeFound_UpgradeAlreadyExists() { CapabilityTypeDefinition type1 = new CapabilityTypeDefinition(); CapabilityTypeDefinition type1_1 = new CapabilityTypeDefinition(); List<Object> elementTypesToCreate = Arrays.asList(type1_1); - - ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); + + ImmutablePair<ElementTypeEnum, String> elementInfo = new ImmutablePair<>(ElementTypeEnum.CAPABILITY_TYPE, "TestCapability"); when(elementInfoGetter.apply(type1_1)).thenReturn(elementInfo); - + when(validator.apply(type1_1)).thenReturn(Either.left(ActionStatus.OK)); when(elementFetcher.apply("TestCapability")).thenReturn(Either.left(type1)); when(elementUpgrader.apply(type1_1, type1)).thenReturn(Either.right(StorageOperationStatus.OK)); - - Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate , validator , elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); + + Either<List<ImmutablePair<Object, Boolean>>, ResponseFormat> result = commonImportManager.createElementTypesByDao(elementTypesToCreate, + validator, elementInfoGetter, elementFetcher, elementAdder, elementUpgrader); verify(elementAdder, never()).apply(Mockito.any()); verify(elementUpgrader).apply(type1_1, type1); verify(janusGraphGenericDao).commit(); - + assertEquals(type1_1, result.left().value().get(0).getLeft()); assertEquals(false, result.left().value().get(0).getRight()); } diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManagerTest.java index a6ee23b392..c288fa82cd 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManagerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/GroupTypeImportManagerTest.java @@ -50,7 +50,7 @@ public class GroupTypeImportManagerTest { public void shouldInvokeCreateElementTypes() { GroupTypeImportManager groupTypeImportManager = new GroupTypeImportManager(groupTypeOperation, componentsUtils, toscaOperationFacade, commonImportManager, modelOperation); - groupTypeImportManager.createGroupTypes(data, null); + groupTypeImportManager.createGroupTypes(data, null, false); Mockito.verify(commonImportManager).createElementTypes(Mockito.any(ToscaTypeImportData.class), Mockito.any(), Mockito.any(), Mockito.any()); } }
\ No newline at end of file diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceLifecycleTypeImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceLifecycleTypeImportManagerTest.java index 0595a4c24d..9aa68d81cd 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceLifecycleTypeImportManagerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/InterfaceLifecycleTypeImportManagerTest.java @@ -20,7 +20,21 @@ package org.openecomp.sdc.be.components.impl; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.not; +import static org.hamcrest.core.Is.is; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.when; + import fj.data.Either; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.List; import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; @@ -41,21 +55,6 @@ import org.openecomp.sdc.be.model.operations.api.StorageOperationStatus; import org.openecomp.sdc.be.model.operations.impl.ModelOperation; import org.openecomp.sdc.exception.ResponseFormat; -import java.io.IOException; -import java.nio.file.Files; -import java.nio.file.Path; -import java.nio.file.Paths; -import java.util.List; - -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.containsInAnyOrder; -import static org.hamcrest.Matchers.empty; -import static org.hamcrest.Matchers.hasSize; -import static org.hamcrest.Matchers.not; -import static org.hamcrest.core.Is.is; -import static org.junit.Assert.assertTrue; -import static org.mockito.Mockito.when; - public class InterfaceLifecycleTypeImportManagerTest { @InjectMocks @@ -67,13 +66,14 @@ public class InterfaceLifecycleTypeImportManagerTest { @BeforeClass public static void beforeClass() throws IOException { - when(interfaceLifecycleOperation.createInterfaceType(Mockito.any(InterfaceDefinition.class))).thenAnswer(new Answer<Either<InterfaceDefinition, StorageOperationStatus>>() { - public Either<InterfaceDefinition, StorageOperationStatus> answer(InvocationOnMock invocation) { - Object[] args = invocation.getArguments(); - return Either.left((InterfaceDefinition) args[0]); - } + when(interfaceLifecycleOperation.createInterfaceType(Mockito.any(InterfaceDefinition.class))).thenAnswer( + new Answer<Either<InterfaceDefinition, StorageOperationStatus>>() { + public Either<InterfaceDefinition, StorageOperationStatus> answer(InvocationOnMock invocation) { + Object[] args = invocation.getArguments(); + return Either.left((InterfaceDefinition) args[0]); + } - }); + }); when(commonImportManager.createElementTypesFromYml(Mockito.anyString(), Mockito.any())).thenCallRealMethod(); when(commonImportManager.createElementTypesFromToscaJsonMap(Mockito.any(), Mockito.any())).thenCallRealMethod(); } @@ -88,7 +88,7 @@ public class InterfaceLifecycleTypeImportManagerTest { final String ymlContent = getYmlContent(); when(modelOperation.findModelByName("test")).thenReturn(Optional.of(new Model("test"))); final Either<List<InterfaceDefinition>, ResponseFormat> createCapabilityTypes = - importManager.createLifecycleTypes(ymlContent, "test"); + importManager.createLifecycleTypes(ymlContent, "test", false); assertTrue(createCapabilityTypes.isLeft()); final List<InterfaceDefinition> interfaceDefinitionList = createCapabilityTypes.left().value(); assertThat("Interface definitions should not be empty", interfaceDefinitionList, is(not(empty()))); @@ -98,10 +98,10 @@ public class InterfaceLifecycleTypeImportManagerTest { final String standardInterfaceType = "tosca.interfaces.node.lifecycle.Standard"; final String nslcmInterfaceType = "tosca.interfaces.nfv.Nslcm"; final Optional<InterfaceDefinition> standardInterfaceOpt = interfaceDefinitionList.stream().filter( - interfaceDefinition -> standardInterfaceType.equals(interfaceDefinition.getType())) + interfaceDefinition -> standardInterfaceType.equals(interfaceDefinition.getType())) .findFirst(); final Optional<InterfaceDefinition> nslcmInterfaceOpt = interfaceDefinitionList.stream().filter( - interfaceDefinition -> nslcmInterfaceType.equals(interfaceDefinition.getType())) + interfaceDefinition -> nslcmInterfaceType.equals(interfaceDefinition.getType())) .findFirst(); assertThat("", standardInterfaceOpt.isPresent(), is(true)); assertThat("", nslcmInterfaceOpt.isPresent(), is(true)); diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java index 08d0787b27..5e9d4e7f5d 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/ModelBusinessLogicTest.java @@ -46,8 +46,8 @@ import org.mockito.MockitoAnnotations; import org.openecomp.sdc.be.dao.api.ActionStatus; import org.openecomp.sdc.be.exception.BusinessException; import org.openecomp.sdc.be.model.Model; -import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.ModelOperationExceptionSupplier; +import org.openecomp.sdc.be.model.jsonjanusgraph.operations.exception.OperationException; import org.openecomp.sdc.be.model.operations.impl.ModelOperation; import org.openecomp.sdc.common.zip.ZipUtils; import org.openecomp.sdc.common.zip.exception.ZipException; @@ -80,7 +80,7 @@ class ModelBusinessLogicTest { assertThat(result).isNotNull(); assertThat(result.getName()).isEqualTo(model.getName()); } - + @Test void createModelWithDataTypesTest() { final String dataTypes = "dummyString"; @@ -88,8 +88,8 @@ class ModelBusinessLogicTest { final Model result = modelBusinessLogic.createModel(model, dataTypes); assertThat(result).isNotNull(); assertThat(result.getName()).isEqualTo(model.getName()); - - verify(dataTypeImportManager).createDataTypes(dataTypes, model.getName()); + + verify(dataTypeImportManager).createDataTypes(dataTypes, model.getName(), false); } @Test @@ -220,4 +220,4 @@ class ModelBusinessLogicTest { final List<Model> actualModelList = modelBusinessLogic.listModels(); assertTrue(actualModelList.isEmpty(), "The model list should be empty"); } -}
\ No newline at end of file +} diff --git a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/RelationshipTypeImportManagerTest.java b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/RelationshipTypeImportManagerTest.java index 06be58d584..5a8a704728 100644 --- a/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/RelationshipTypeImportManagerTest.java +++ b/catalog-be/src/test/java/org/openecomp/sdc/be/components/impl/RelationshipTypeImportManagerTest.java @@ -44,7 +44,7 @@ public class RelationshipTypeImportManagerTest { public void shouldInvokeCreateElementTypes() { RelationshipTypeImportManager relationshipTypeImportManager = new RelationshipTypeImportManager(relationshipTypeOperation, commonImportManager, componentsUtils, modelOperation); - relationshipTypeImportManager.createRelationshipTypes("anyYaml", "anyModel"); + relationshipTypeImportManager.createRelationshipTypes("anyYaml", "anyModel", false); Mockito.verify(commonImportManager).createElementTypes((String) Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()); } |