1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
/*
* ============LICENSE_START=======================================================
* Copyright (C) 2021 Nordix Foundation
* ================================================================================
* 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.
*
* SPDX-License-Identifier: Apache-2.0
* ============LICENSE_END=========================================================
*/
package org.onap.cps.spi.impl;
import static junit.framework.TestCase.assertEquals;
import com.google.common.collect.ImmutableSet;
import java.util.Collections;
import org.junit.ClassRule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.onap.cps.DatabaseTestContainer;
import org.onap.cps.spi.CpsDataPersistenceService;
import org.onap.cps.spi.entities.FragmentEntity;
import org.onap.cps.spi.exceptions.AnchorNotFoundException;
import org.onap.cps.spi.exceptions.DataspaceNotFoundException;
import org.onap.cps.spi.model.DataNode;
import org.onap.cps.spi.repository.FragmentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.test.context.jdbc.Sql;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class CpsDataPersistenceServiceTest {
private static final String CLEAR_DATA = "/data/clear-all.sql";
private static final String SET_DATA = "/data/fragment.sql";
private static final String NON_EXISTING_DATASPACE_NAME = "NON EXISTING DATASPACE";
private static final String DATASPACE_NAME = "DATASPACE-001";
private static final String ANCHOR_NAME1 = "ANCHOR-001";
private static final String NON_EXISTING_ANCHOR_NAME = "NON EXISTING ANCHOR";
private static final String PARENT_XPATH = "/parent";
private static final String CHILD_XPATH = "/parent/child";
private static final String GRAND_CHILD_XPATH = "/parent/child/grandchild";
private static final String PARENT_XPATH_NEW = "/parent-new";
private static final String CHILD_XPATH_NEW = "/parent/child-new";
private static final String GRAND_CHILD_XPATH_NEW = "/parent/child/grandchild-new";
private static final long PARENT_ID = 3001;
private static final long CHILD_ID = 3002;
private static final long GRAND_CHILD_ID = 3003;
private static final long PARENT_ID_NEW = 2;
private static final long CHILD_ID_NEW = 3;
private static final long GRAND_CHILD_ID_NEW = 4;
@ClassRule
public static DatabaseTestContainer databaseTestContainer = DatabaseTestContainer.getInstance();
@Autowired
private CpsDataPersistenceService cpsDataPersistenceService;
@Autowired
private FragmentRepository fragmentRepository;
@Test
@Sql({CLEAR_DATA, SET_DATA})
public void testGetFragmentsWithChildAndGrandChild() {
final FragmentEntity parentFragment = fragmentRepository.findById(PARENT_ID).orElseThrow();
final FragmentEntity childFragment = fragmentRepository.findById(CHILD_ID).orElseThrow();
final FragmentEntity grandChildFragment = fragmentRepository.findById(GRAND_CHILD_ID).orElseThrow();
assertFragment(parentFragment, childFragment, grandChildFragment, PARENT_XPATH, CHILD_XPATH, GRAND_CHILD_XPATH);
}
@Test(expected = DataspaceNotFoundException.class)
@Sql({CLEAR_DATA, SET_DATA})
public void testStoreDataNodeAtNonExistingDataspace() {
cpsDataPersistenceService
.storeDataNode(NON_EXISTING_DATASPACE_NAME, ANCHOR_NAME1,
createDataNodeWithChildAndGrandChild(PARENT_XPATH_NEW, CHILD_XPATH_NEW, GRAND_CHILD_XPATH_NEW));
}
@Test(expected = AnchorNotFoundException.class)
@Sql({CLEAR_DATA, SET_DATA})
public void testStoreDataNodeAtNonExistingAnchor() {
cpsDataPersistenceService
.storeDataNode(DATASPACE_NAME, NON_EXISTING_ANCHOR_NAME,
createDataNodeWithChildAndGrandChild(PARENT_XPATH_NEW, CHILD_XPATH_NEW, GRAND_CHILD_XPATH_NEW));
}
@Test(expected = DataIntegrityViolationException.class)
@Sql({CLEAR_DATA, SET_DATA})
public void testStoreDataNodeWithIntegrityException() {
cpsDataPersistenceService.storeDataNode(DATASPACE_NAME, ANCHOR_NAME1,
createDataNodeWithChildAndGrandChild(PARENT_XPATH, CHILD_XPATH, GRAND_CHILD_XPATH));
}
@Test
@Sql({CLEAR_DATA, SET_DATA})
public void testStoreDataNodeWithChildrenAndGrandChildren() {
cpsDataPersistenceService.storeDataNode(DATASPACE_NAME, ANCHOR_NAME1,
createDataNodeWithChildAndGrandChild(PARENT_XPATH_NEW, CHILD_XPATH_NEW, GRAND_CHILD_XPATH_NEW));
final FragmentEntity parentFragment = fragmentRepository.findById(PARENT_ID_NEW).orElseThrow();
final FragmentEntity childFragment = fragmentRepository.findById(CHILD_ID_NEW).orElseThrow();
final FragmentEntity grandChildFragment = fragmentRepository.findById(GRAND_CHILD_ID_NEW).orElseThrow();
assertFragment(parentFragment, childFragment, grandChildFragment, PARENT_XPATH_NEW, CHILD_XPATH_NEW,
GRAND_CHILD_XPATH_NEW);
}
private void assertFragment(final FragmentEntity parentFragment, final FragmentEntity childFragment,
final FragmentEntity grandChildFragment, final String parentXpath, final String childXpath,
final String grandChildXpath) {
assertEquals(parentXpath, parentFragment.getXpath());
assertEquals(DATASPACE_NAME, parentFragment.getDataspace().getName());
assertEquals(ANCHOR_NAME1, parentFragment.getAnchor().getName());
assertEquals(childXpath, childFragment.getXpath());
assertEquals(DATASPACE_NAME, childFragment.getDataspace().getName());
assertEquals(ANCHOR_NAME1, childFragment.getAnchor().getName());
assertEquals(grandChildXpath, grandChildFragment.getXpath());
assertEquals(DATASPACE_NAME, grandChildFragment.getDataspace().getName());
assertEquals(ANCHOR_NAME1, grandChildFragment.getAnchor().getName());
}
private DataNode createDataNodeWithChildAndGrandChild(final String parentXpath, final String childXpath,
final String grandChildXpath) {
final DataNode parentDataNode = DataNode.builder()
.xpath(parentXpath)
.build();
final DataNode childDataNode = DataNode.builder()
.xpath(childXpath)
.childDataNodes(Collections.emptySet())
.build();
final DataNode grandChildDataNode = DataNode.builder()
.xpath(grandChildXpath)
.childDataNodes(Collections.emptySet())
.build();
parentDataNode.setChildDataNodes(ImmutableSet.of(childDataNode));
childDataNode.setChildDataNodes(ImmutableSet.of(grandChildDataNode));
return parentDataNode;
}
}
|
