@Override
public void createExpectationObject(ExpectationObject expectationObject, String expectationId) {
+ if (expectationObjectService.getExpectationObject(expectationId) != null) {
+ String msg = String.format("It already exists an object for the expectation %s, update might work.", expectationId);
+ log.error(msg);
+ throw new DataBaseException(msg, ResponseConsts.RET_INSERT_DATA_FAIL);
+ }
contextService.createContextList(expectationObject.getObjectContexts(),
expectationObjectMapper.selectExpectationObjectId(expectationId));
if (expectationObjectMapper.insertExpectationObject(expectationObject, expectationId) < 1) {
}
expectationTargetIdListFromDB.remove(expectationTargetId);
} else {
- expectationTargetService.createExpectationTarget(expectationTarget, expectationTargetId);
+ expectationTargetService.createExpectationTarget(expectationTarget, expectationId);
}
}
for (String expectationTargetIdFromDB : expectationTargetIdListFromDB) {
</update>
<delete id="deleteContext">
- DELETE FROM context WHERE context_id = #{context.contextId}
+ DELETE
+ FROM context
+ WHERE context_id = #{contextId}
</delete>
<delete id="deleteContextList">
- DELETE FROM context WHERE parent_id = #{parentId}
+ DELETE
+ FROM context
+ WHERE parent_id = #{parentId}
</delete>
</mapper>
</insert>
<select id="selectIntentExpectationList" resultType="org.onap.usecaseui.intentanalysis.bean.models.Expectation">
- select expectation_id expectationId, expectation_name expectationName, expectation_type expectationType,
- intent_id intentId
+ select expectation_id expectationId, expectation_name expectationName, expectation_type expectationType
from expectation
where intent_id = #{intentId}
</select>
<select id="selectIntentExpectation" resultType="org.onap.usecaseui.intentanalysis.bean.models.Expectation">
- select expectation_id expectationId, expectation_name expectationName, expectation_type expectationType,
- intent_id intentId
+ select expectation_id expectationId, expectation_name expectationName, expectation_type expectationType
from expectation
where expectation_id = #{expectationId}
</select>
--- /dev/null
+package org.onap.usecaseui.intentanalysis.service;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
+import org.onap.usecaseui.intentanalysis.IntentAnalysisApplicationTests;
+import org.onap.usecaseui.intentanalysis.bean.models.Context;
+import org.onap.usecaseui.intentanalysis.exception.DataBaseException;
+import org.onap.usecaseui.intentanalysis.util.SpringContextUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+import org.springframework.test.context.junit4.SpringRunner;
+
+
+@SpringBootTest(classes = IntentAnalysisApplicationTests.class)
+@RunWith(SpringRunner.class)
+class ContextServiceTest extends AbstractJUnit4SpringContextTests {
+
+ private static final String TEST_INTENT_ID_1 = "intentId1";
+
+ private static final String TEST_INTENT_ID_2 = "intentId2";
+
+ private static final String TEST_INTENT_ID_3 = "intent without affiliate";
+
+ private static final String TEST_EXPECTATION_ID = "expectation without affiliate";
+
+ private static final String TEST_CONTEXT_ID_1 = "d64f3a5f-b091-40a6-bca0-1bc6b1ce8f43";
+
+ @Autowired
+ private ContextService contextService;
+
+ public Context createTestContext(String testName) {
+ Context context = new Context();
+ context.setContextId(testName + "-contextId");
+ context.setContextName(testName + "contextName");
+
+ return context;
+ }
+
+ public List<Context> createTestContextList(String testName) {
+ List<Context> contextList = new ArrayList<>();
+ contextList.add(createTestContext(testName));
+ return contextList;
+ }
+
+ @BeforeEach
+ void setUp() {
+ SpringContextUtil.setApplicationContext(applicationContext);
+ }
+
+ @Test
+ void testCreateContextListSuccess() {
+ List<Context> contextList = createTestContextList("testCreateContextListSuccess");
+
+ try {
+ contextService.createContextList(contextList, TEST_INTENT_ID_3);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertNotNull(contextService.getContextList(TEST_INTENT_ID_3));
+ }
+
+ @Test
+ void testCreateContextSuccess() {
+ Context context = createTestContext("testCreateContextSuccess");
+
+ try {
+ contextService.createContext(context, TEST_INTENT_ID_1);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertNotNull(contextService.getContext(context.getContextId()));
+ }
+
+ @Test
+ void testDeleteContextSuccess() {
+ contextService.deleteContext(TEST_CONTEXT_ID_1);
+ Context context = contextService.getContext(TEST_CONTEXT_ID_1);
+ Assert.assertNull(context);
+ }
+
+ @Test
+ void testUpdateContextListSuccess() {
+ List<Context> contextList = contextService.getContextList(TEST_INTENT_ID_2);
+ Context context = contextList.get(0);
+ context.setContextName("new context name");
+
+ try {
+ contextService.updateContextList(contextList, TEST_INTENT_ID_2);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Context contextTmp = contextService.getContextList(TEST_INTENT_ID_2).get(0);
+ Assert.assertEquals("new context name", contextTmp.getContextName());
+ }
+
+ @Test
+ void testUpdateContextListSuccessToNull() {
+ List<Context> contextList = createTestContextList("testUpdateContextListSuccess_2");
+
+ try {
+ contextService.updateContextList(contextList, TEST_EXPECTATION_ID);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertNotNull(contextService.getContextList(TEST_EXPECTATION_ID));
+ }
+
+ @Test
+ void testGetContextListSuccess() {
+ List<Context> contextList = contextService.getContextList(TEST_INTENT_ID_1);
+ Assert.assertNotNull(contextList);
+ }
+}
\ No newline at end of file
--- /dev/null
+package org.onap.usecaseui.intentanalysis.service;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
+import org.onap.usecaseui.intentanalysis.bean.enums.ObjectType;
+import org.onap.usecaseui.intentanalysis.bean.models.Context;
+import org.onap.usecaseui.intentanalysis.bean.models.ExpectationObject;
+import org.onap.usecaseui.intentanalysis.exception.DataBaseException;
+import org.onap.usecaseui.intentanalysis.IntentAnalysisApplicationTests;
+import org.onap.usecaseui.intentanalysis.util.SpringContextUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+import org.springframework.test.context.junit4.SpringRunner;
+
+@SpringBootTest(classes = IntentAnalysisApplicationTests.class)
+@RunWith(SpringRunner.class)
+class ExpectationObjectServiceTest extends AbstractJUnit4SpringContextTests {
+
+ private static final String TEST_EXPECTATION_ID_1 = "expectationId1";
+
+ private static final String TEST_EXPECTATION_ID_2 = "expectation without affiliate";
+
+ private static final String TEST_EXPECTATION_ID_3 = "expectationId3";
+
+ @Autowired
+ private ExpectationObjectService expectationObjectService;
+
+ public ExpectationObject createTestObject(String testName) {
+ ExpectationObject expectationObject = new ExpectationObject();
+ expectationObject.setObjectType(ObjectType.OBJECT1);
+ expectationObject.setObjectInstance("true");
+
+ List<Context> contextList = new ArrayList<>();
+ Context context = new Context();
+ context.setContextId(testName + "-contextId");
+ context.setContextName(testName + "-contextName");
+ contextList.add(context);
+ expectationObject.setObjectContexts(contextList);
+
+ return expectationObject;
+ }
+
+ @BeforeEach
+ void setUp() {
+ SpringContextUtil.setApplicationContext(applicationContext);
+ }
+
+ @Test
+ void testCreateExpectationObjectFalse() {
+ ExpectationObject expectationObject = createTestObject("testCreateExpectationObjectFalse");
+
+ try {
+ expectationObjectService.createExpectationObject(expectationObject, TEST_EXPECTATION_ID_1);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ String msg = String.format("It already exists an object for the expectation %s, update might work.", TEST_EXPECTATION_ID_1);
+ Assert.assertEquals(msg, exception.getMessage());
+ }
+ }
+
+ @Test
+ void testCreateExpectationObjectSuccess() {
+ ExpectationObject expectationObject = createTestObject("testCreateExpectationObjectSuccess");
+
+ try {
+ expectationObjectService.createExpectationObject(expectationObject, TEST_EXPECTATION_ID_2);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+ Assert.assertNotNull(expectationObjectService.getExpectationObject(TEST_EXPECTATION_ID_2));
+ }
+
+ @Test
+ void testGetExpectationObjectSuccess() {
+ ExpectationObject expectationObject = expectationObjectService.getExpectationObject(TEST_EXPECTATION_ID_1);
+ Assert.assertNotNull(expectationObject);
+ }
+
+ @Test
+ void testUpdateExpectationObjectSuccess() {
+ String testName = "testUpdateExpectationObjectSuccess_1";
+ ExpectationObject expectationObject = createTestObject(testName);
+
+ try {
+ expectationObjectService.updateExpectationObject(expectationObject, TEST_EXPECTATION_ID_1);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ ExpectationObject expectationObjectTmp = expectationObjectService.getExpectationObject(TEST_EXPECTATION_ID_1);
+ Assert.assertEquals(expectationObjectTmp.getObjectContexts().get(0).getContextName(), testName + "-contextName");
+ }
+
+ @Test
+ void testUpdateExpectationObjectToNullSuccess() {
+ ExpectationObject expectationObject = new ExpectationObject();
+ expectationObject.setObjectType(ObjectType.OBJECT2);
+
+ try {
+ expectationObjectService.updateExpectationObject(expectationObject, TEST_EXPECTATION_ID_2);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ ExpectationObject expectationObjectUpdated = expectationObjectService.getExpectationObject(TEST_EXPECTATION_ID_2);
+ Assert.assertNotNull(expectationObjectUpdated);
+ }
+
+ @Test
+ void testDeleteExpectationObjectSuccess() {
+ try {
+ expectationObjectService.deleteExpectationObject(TEST_EXPECTATION_ID_3);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ ExpectationObject expectationObject = expectationObjectService.getExpectationObject(TEST_EXPECTATION_ID_3);
+ Assert.assertNull(expectationObject);
+ }
+}
\ No newline at end of file
--- /dev/null
+package org.onap.usecaseui.intentanalysis.service;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
+import org.onap.usecaseui.intentanalysis.bean.enums.ExpectationType;
+import org.onap.usecaseui.intentanalysis.bean.enums.FulfilmentStatus;
+import org.onap.usecaseui.intentanalysis.bean.enums.NotFulfilledState;
+import org.onap.usecaseui.intentanalysis.bean.enums.ObjectType;
+import org.onap.usecaseui.intentanalysis.bean.enums.OperatorType;
+import org.onap.usecaseui.intentanalysis.bean.models.Condition;
+import org.onap.usecaseui.intentanalysis.bean.models.Expectation;
+import org.onap.usecaseui.intentanalysis.bean.models.ExpectationObject;
+import org.onap.usecaseui.intentanalysis.bean.models.ExpectationTarget;
+import org.onap.usecaseui.intentanalysis.bean.models.FulfilmentInfo;
+import org.onap.usecaseui.intentanalysis.exception.DataBaseException;
+import org.onap.usecaseui.intentanalysis.IntentAnalysisApplicationTests;
+import org.onap.usecaseui.intentanalysis.util.SpringContextUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.util.CollectionUtils;
+
+
+@SpringBootTest(classes = IntentAnalysisApplicationTests.class)
+@RunWith(SpringRunner.class)
+class ExpectationServiceTest extends AbstractJUnit4SpringContextTests {
+
+ private static final String TEST_INTENT_ID_1 = "intentId1";
+
+ private static final String TEST_INTENT_ID_2 = "intentId2";
+
+ private static final String TEST_INTENT_ID_3 = "intent without affiliate";
+
+ private static final String TEST_EXPECTATION_ID_1 = "expectationId1";
+
+ private static final String TEST_EXPECTATION_ID_2= "expectationId2";
+
+ @Autowired
+ private ExpectationService expectationService;
+
+ public Expectation createTestExpectation(String testName) {
+ Expectation expectation = new Expectation();
+
+ ExpectationObject object = new ExpectationObject();
+ object.setObjectType(ObjectType.valueOf("OBJECT1"));
+ object.setObjectInstance("objectInstance");
+
+ Condition targetCondition = new Condition();
+ targetCondition.setConditionId(testName + "-conditionId");
+ targetCondition.setConditionName(testName + "conditionName");
+ targetCondition.setOperator(OperatorType.valueOf("EQUALTO"));
+ targetCondition.setConditionValue("conditionValue");
+ List<Condition> targetConditionList = new ArrayList<>();
+ targetConditionList.add(targetCondition);
+
+ ExpectationTarget target = new ExpectationTarget();
+ target.setTargetId(testName + "targetId");
+ target.setTargetName(testName + "targetName");
+ target.setTargetConditions(targetConditionList);
+ List<ExpectationTarget> expectationTargetList = new ArrayList<>();
+ expectationTargetList.add(target);
+
+ FulfilmentInfo expectationFulfilmentInfo = new FulfilmentInfo();
+ expectationFulfilmentInfo.setFulfilmentStatus(FulfilmentStatus.valueOf("NOT_FULFILLED"));
+ expectationFulfilmentInfo.setNotFulfilledReason("NotFulfilledReason");
+ expectationFulfilmentInfo.setNotFulfilledState(NotFulfilledState.valueOf("COMPLIANT"));
+
+ expectation.setExpectationId(testName + "-expectationId");
+ expectation.setExpectationName(testName + "expectationName");
+ expectation.setExpectationType(ExpectationType.valueOf("DELIVERY"));
+ expectation.setExpectationObject(object);
+ expectation.setExpectationTargets(expectationTargetList);
+ expectation.setExpectationFulfilmentInfo(expectationFulfilmentInfo);
+
+ return expectation;
+ }
+
+ @BeforeEach
+ public void setUp() {
+ SpringContextUtil.setApplicationContext(applicationContext);
+ }
+
+ @Test
+ public void testCreateIntentExpectationSuccess() {
+ Expectation expectation = createTestExpectation("testCreateIntentExpectationSuccess");
+
+ try {
+ expectationService.createIntentExpectation(expectation, TEST_INTENT_ID_3);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertNotNull(expectationService.getIntentExpectation(expectation.getExpectationId()));
+ }
+
+ @Test
+ public void testCreateIntentExpectationListSuccess() {
+ List<Expectation> expectationList = new ArrayList<>();
+ Expectation expectation = createTestExpectation("testCreateIntentExpectationListSuccess");
+ expectationList.add(expectation);
+
+ try {
+ expectationService.createIntentExpectationList(expectationList, TEST_INTENT_ID_3);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertNotNull(expectationService.getIntentExpectation(expectation.getExpectationId()));
+ }
+
+ @Test
+ public void testDeleteIntentExpectationListSuccess() {
+ try {
+ expectationService.deleteIntentExpectation(TEST_EXPECTATION_ID_1);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertNull(expectationService.getIntentExpectation(TEST_EXPECTATION_ID_1));
+ }
+
+ @Test
+ public void deleteIntentExpectationSuccess() {
+ try {
+ expectationService.deleteIntentExpectationList(TEST_INTENT_ID_2);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertTrue(CollectionUtils.isEmpty(expectationService.getIntentExpectationList(TEST_INTENT_ID_2)));
+ }
+
+ @Test
+ public void testUpdateIntentExpectationListSuccess() {
+ List<Expectation> expectationList = new ArrayList<>();
+ Expectation expectation = createTestExpectation("testUpdateIntentExpectationListSuccess");
+ expectationList.add(expectation);
+
+ try {
+ expectationService.updateIntentExpectationList(expectationList, TEST_INTENT_ID_2);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Expectation updatedExpectation = expectationService.getIntentExpectationList(TEST_INTENT_ID_2).get(0);
+ Assert.assertEquals(updatedExpectation.getExpectationId(), expectation.getExpectationId());
+ }
+
+ @Test
+ public void testGetIntentExpectationListSuccess() {
+ List<Expectation> expectationList = expectationService.getIntentExpectationList(TEST_INTENT_ID_1);
+ Assert.assertFalse(CollectionUtils.isEmpty(expectationList));
+ }
+
+ @Test
+ public void testGetIntentExpectationSuccess() {
+ Expectation expectationGotten = expectationService.getIntentExpectation(TEST_EXPECTATION_ID_2);
+ Assert.assertNotNull(expectationGotten);
+ }
+
+}
--- /dev/null
+package org.onap.usecaseui.intentanalysis.service;
+
+import java.util.ArrayList;
+import java.util.List;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Assert;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.runner.RunWith;
+import org.onap.usecaseui.intentanalysis.bean.enums.OperatorType;
+import org.onap.usecaseui.intentanalysis.bean.models.Condition;
+import org.onap.usecaseui.intentanalysis.bean.models.ExpectationTarget;
+import org.onap.usecaseui.intentanalysis.exception.DataBaseException;
+import org.onap.usecaseui.intentanalysis.IntentAnalysisApplicationTests;
+import org.onap.usecaseui.intentanalysis.util.SpringContextUtil;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
+import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.util.CollectionUtils;
+
+@SpringBootTest(classes = IntentAnalysisApplicationTests.class)
+@RunWith(SpringRunner.class)
+@Slf4j
+class ExpectationTargetServiceTest extends AbstractJUnit4SpringContextTests {
+
+ private static final String TEST_EXPECTATION_ID_1 = "expectation without affiliate";
+
+ private static final String TEST_EXPECTATION_ID_2 = "expectationId2";
+
+ private static final String TEST_EXPECTATION_ID_3 = "expectationId3";
+
+ private static final String TEST_EXPECTATION_ID_4 = "expectationId4";
+
+ private static final String TEST_TARGET_ID_1 = "target1-1";
+
+ private static final String TEST_TARGET_ID_2 = "target2-2";
+
+ @Autowired
+ private ExpectationTargetService expectationTargetService;
+
+ public ExpectationTarget createTestTarget(String testName) {
+ ExpectationTarget target = new ExpectationTarget();
+
+ Condition targetCondition = new Condition();
+ targetCondition.setConditionId(testName + "-conditionId");
+ targetCondition.setConditionName(testName + "conditionName");
+ targetCondition.setOperator(OperatorType.valueOf("EQUALTO"));
+ targetCondition.setConditionValue("conditionValue");
+ List<Condition> targetConditionList = new ArrayList<>();
+ targetConditionList.add(targetCondition);
+
+ target.setTargetId(testName + "-targetId");
+ target.setTargetName(testName + "targetName");
+ target.setTargetConditions(targetConditionList);
+
+ return target;
+ }
+
+ @BeforeEach
+ void setUp() {
+ SpringContextUtil.setApplicationContext(applicationContext);
+ }
+
+ @Test
+ void testCreateExpectationTargetSuccess() {
+ ExpectationTarget expectationTarget = createTestTarget("testCreateExpectationTargetSuccess");
+ try {
+ expectationTargetService.createExpectationTarget(expectationTarget, TEST_EXPECTATION_ID_2);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+ List<ExpectationTarget> expectationTargetList = expectationTargetService.getExpectationTargetList(
+ TEST_EXPECTATION_ID_2);
+ List<String> targetIdList = new ArrayList<>();
+ for (ExpectationTarget target : expectationTargetList) {
+ targetIdList.add(target.getTargetId());
+ }
+
+ Assert.assertTrue(targetIdList.contains(expectationTarget.getTargetId()));
+ }
+
+ @Test
+ void testCreateExpectationTargetListSuccess() {
+ ExpectationTarget expectationTarget = createTestTarget("testCreateExpectationTargetListSuccess");
+ List<ExpectationTarget> expectationTargetList = new ArrayList<>();
+ expectationTargetList.add(expectationTarget);
+
+ try {
+ expectationTargetService.createExpectationTargetList(expectationTargetList, TEST_EXPECTATION_ID_4);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ Assert.assertFalse(CollectionUtils.isEmpty(expectationTargetService.getExpectationTargetList(
+ TEST_EXPECTATION_ID_4)));
+ }
+
+ @Test
+ void testGetExpectationTargetListSuccess() {
+ List<ExpectationTarget> expectationTargetList = expectationTargetService.getExpectationTargetList(
+ TEST_EXPECTATION_ID_2);
+ Assert.assertFalse(CollectionUtils.isEmpty(expectationTargetList));
+ }
+
+ @Test
+ void testGetExpectationTargetSuccess() {
+ ExpectationTarget target = expectationTargetService.getExpectationTarget(TEST_TARGET_ID_1);
+ Assert.assertNotNull(target);
+ }
+
+ @Test
+ void testUpdateExpectationTargetListSuccess() {
+ ExpectationTarget expectationTarget = createTestTarget("testUpdateExpectationTargetListSuccess");
+ List<ExpectationTarget> expectationTargetList = new ArrayList<>();
+ expectationTargetList.add(expectationTarget);
+
+ try {
+ expectationTargetService.updateExpectationTargetList(expectationTargetList, TEST_EXPECTATION_ID_3);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ ExpectationTarget updatedTarget = expectationTargetService.getExpectationTargetList(TEST_EXPECTATION_ID_3).get(0);
+ Assert.assertEquals(expectationTargetList.get(0).getTargetId(), updatedTarget.getTargetId());
+ }
+
+ @Test
+ void testDeleteExpectationTargetSuccess() {
+ try {
+ expectationTargetService.deleteExpectationTarget(TEST_TARGET_ID_2);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ List<ExpectationTarget> expectationTargetList = expectationTargetService.getExpectationTargetList(
+ TEST_EXPECTATION_ID_2);
+ for (ExpectationTarget target : expectationTargetList) {
+ Assert.assertNotEquals(TEST_TARGET_ID_2, target.getTargetId());
+ }
+ }
+
+ @Test
+ void testDeleteExpectationTargetListSuccess() {
+ try {
+ expectationTargetService.deleteExpectationTargetList(TEST_EXPECTATION_ID_1);
+ } catch (DataBaseException exception) {
+ exception.printStackTrace();
+ }
+
+ List<ExpectationTarget> expectationTargetList = expectationTargetService.getExpectationTargetList(
+ TEST_EXPECTATION_ID_1);
+ Assert.assertTrue(CollectionUtils.isEmpty(expectationTargetList));
+ }
+}
\ No newline at end of file
import org.onap.usecaseui.intentanalysis.bean.models.ExpectationObject;
import org.onap.usecaseui.intentanalysis.IntentAnalysisApplicationTests;
import org.onap.usecaseui.intentanalysis.util.SpringContextUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringRunner;
+import org.springframework.util.CollectionUtils;
@SpringBootTest(classes = IntentAnalysisApplicationTests.class)
@RunWith(SpringRunner.class)
public class IntentServiceTest extends AbstractJUnit4SpringContextTests {
- private static final Logger LOGGER = LoggerFactory.getLogger(IntentServiceTest.class);
-
private static final String TEST_INTENT_ID_1 = "intentId1";
private static final String TEST_INTENT_ID_2 = "intentId2";
@Test
public void testGetIntentListSuccess() {
List<Intent> intentList = intentService.getIntentList();
- Assert.assertNotNull(intentList);
+ Assert.assertFalse(CollectionUtils.isEmpty(intentList));
}
@Test
expectationTarget.setTargetName("new target name");
List<Condition> targetConditionList = expectationTarget.getTargetConditions();
Condition targetCondition = targetConditionList.get(0);
- targetCondition.setConditionName("new conditon name");
+ targetCondition.setConditionName("new condition name");
targetConditionList.set(0, targetCondition);
expectationTarget.setTargetConditions(targetConditionList);
expectationTargetList.remove(2);
values ('intentId1', 'CLL Business intent');
MERGE INTO intent (intent_id, intent_name) KEY (intent_id)
values ('intentId2', 'CLL Business intent');
+MERGE INTO intent (intent_id, intent_name) KEY (intent_id)
+values ('intent without affiliate', 'CLL Business intent');
-- ----------------------------
-- Records of expectation
values ('expectationId2', 'CLL Assurance Expectation', 'ASSURANCE', 'intentId1');
MERGE INTO expectation (expectation_id, expectation_name, expectation_type, intent_id) KEY (expectation_id)
values ('expectationId3', 'CLL Service Expectation', 'DELIVERY', 'intentId2');
+MERGE INTO expectation (expectation_id, expectation_name, expectation_type, intent_id) KEY (expectation_id)
+values ('expectationId4', 'CLL Service Expectation', 'DELIVERY', 'intentId2');
+MERGE INTO expectation (expectation_id, expectation_name, expectation_type, intent_id) KEY (expectation_id)
+values ('expectation without affiliate', 'CLL Assurance Expectation', 'DELIVERY', 'intentId2');
+MERGE INTO expectation (expectation_id, expectation_name, expectation_type, intent_id) KEY (expectation_id)
+values ('expectation without affiliate 2', 'CLL Assurance Expectation', 'ASSURANCE', 'intentId2');
-- ----------------------------
-- Records of expectation_object
MERGE INTO expectation_target (target_id, target_name, expectation_id) KEY (target_id)
values ('target2-1', 'bandwidthAssurance', 'expectationId2');
MERGE INTO expectation_target (target_id, target_name, expectation_id) KEY (target_id)
+values ('target2-2', 'bandwidthAssurance', 'expectationId2');
+MERGE INTO expectation_target (target_id, target_name, expectation_id) KEY (target_id)
+values ('target2-3', 'bandwidthAssurance', 'expectationId2');
+MERGE INTO expectation_target (target_id, target_name, expectation_id) KEY (target_id)
values ('target3-1', 'source', 'expectationId3');
+MERGE INTO expectation_target (target_id, target_name, expectation_id) KEY (target_id)
+values ('target4-1', 'source', 'expectationId4');
-- ----------------------------
-- Records of condition
Code Review / usecase-ui / intent-analysis.git / commitdiff