2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2019-2021 Nordix Foundation.
4 * Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
5 * ================================================================================
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
18 * SPDX-License-Identifier: Apache-2.0
19 * ============LICENSE_END=========================================================
22 package org.onap.policy.models.dao;
24 import static org.assertj.core.api.Assertions.assertThat;
25 import static org.assertj.core.api.Assertions.assertThatCode;
26 import static org.assertj.core.api.Assertions.assertThatThrownBy;
27 import static org.junit.Assert.assertEquals;
28 import static org.junit.Assert.assertNotNull;
29 import static org.junit.Assert.assertNull;
31 import java.time.Instant;
32 import java.util.ArrayList;
33 import java.util.Date;
34 import java.util.HashMap;
35 import java.util.List;
37 import java.util.Properties;
39 import java.util.TreeSet;
40 import java.util.UUID;
41 import org.eclipse.persistence.config.PersistenceUnitProperties;
42 import org.junit.After;
43 import org.junit.Test;
44 import org.onap.policy.models.base.PfConceptKey;
45 import org.onap.policy.models.base.PfGeneratedIdKey;
46 import org.onap.policy.models.base.PfModelException;
47 import org.onap.policy.models.base.PfReferenceKey;
48 import org.onap.policy.models.base.PfReferenceTimestampKey;
49 import org.onap.policy.models.base.PfTimestampKey;
50 import org.onap.policy.models.dao.impl.DefaultPfDao;
55 public class EntityTest {
56 private static final String DESCRIPTION2 = "key description 2";
57 private static final String DESCRIPTION1 = "key description 1";
58 private static final String DESCRIPTION0 = "key description 0";
59 private static final String ENTITY0 = "Entity0";
60 private static final String UUID2 = "00000000-0000-0000-0000-000000000002";
61 private static final String UUID1 = "00000000-0000-0000-0000-000000000001";
62 private static final String UUID0 = "00000000-0000-0000-0000-000000000000";
63 private static final String VERSION003 = "0.0.3";
64 private static final String VERSION002 = "0.0.2";
65 private static final String VERSION001 = "0.0.1";
66 private static final Instant TIMESTAMP0 = Instant.ofEpochSecond(1613494293);
67 private static final Instant TIMESTAMP1 = Instant.ofEpochSecond(1613494293).plusSeconds(55);
68 private static final Instant TIMESTAMP2 = Instant.ofEpochSecond(1613494293).plusSeconds(90);
69 private static final Long GENERATEDID0 = 10000L;
70 private static final Long GENERATEDID1 = 10001L;
71 private static final Long GENERATEDID2 = 10002L;
79 public void tearDown() {
87 public void testEntityTestSanity() throws PfModelException {
88 final DaoParameters daoParameters = new DaoParameters();
90 Properties jdbcProperties = new Properties();
92 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
93 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:EntityTest");
94 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "sa");
95 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "");
98 daoParameters.setJdbcProperties(jdbcProperties);
100 pfDao = new PfDaoFactory().createPfDao(daoParameters);
102 assertThatThrownBy(() -> pfDao.init(null)).hasMessage("Policy Framework persistence unit parameter not set");
104 assertThatThrownBy(() -> pfDao.init(daoParameters))
105 .hasMessage("Policy Framework persistence unit parameter not set");
107 daoParameters.setPluginClass("somewhere.over.the.rainbow");
108 daoParameters.setPersistenceUnit("Dorothy");
110 assertThatThrownBy(() -> pfDao.init(daoParameters))
111 .hasMessage("Creation of Policy Framework persistence unit \"Dorothy\" failed");
113 assertThatThrownBy(() -> pfDao.create(new PfConceptKey()))
114 .hasMessage("Policy Framework DAO has not been initialized");
118 public void testEntityTestAllOpsJpa() throws PfModelException {
120 final DaoParameters daoParameters = new DaoParameters();
121 daoParameters.setPluginClass(DefaultPfDao.class.getName());
122 daoParameters.setPersistenceUnit("DaoTest");
124 Properties jdbcProperties = new Properties();
125 jdbcProperties.setProperty("javax.persistence.jdbc.driver", "org.h2.Driver");
126 jdbcProperties.setProperty("javax.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
127 jdbcProperties.setProperty("javax.persistence.jdbc.user", "sa");
128 jdbcProperties.setProperty("javax.persistence.jdbc.password", "");
130 daoParameters.setJdbcProperties(jdbcProperties);
132 pfDao = new PfDaoFactory().createPfDao(daoParameters);
133 pfDao.init(daoParameters);
139 testReferenceTimestamp();
143 testgetFilteredOps();
145 testgetFilteredOps2();
147 testgetFilteredOps3();
151 public void testEntityTestBadVals() throws PfModelException {
152 final DaoParameters daoParameters = new DaoParameters();
153 daoParameters.setPluginClass(DefaultPfDao.class.getName());
154 daoParameters.setPersistenceUnit("DaoTest");
156 pfDao = new PfDaoFactory().createPfDao(daoParameters);
157 pfDao.init(daoParameters);
159 final PfConceptKey nullKey = null;
160 final PfReferenceKey nullRefKey = null;
161 final PfTimestampKey nullTimeKey = null;
162 final List<PfConceptKey> nullKeyList = null;
163 final List<PfConceptKey> emptyKeyList = new ArrayList<>();
164 final List<PfReferenceKey> nullRKeyList = null;
165 final List<PfReferenceKey> emptyRKeyList = new ArrayList<>();
167 pfDao.create(nullKey);
168 pfDao.createCollection(nullKeyList);
169 pfDao.createCollection(emptyKeyList);
171 pfDao.delete(nullKey);
172 pfDao.deleteCollection(nullKeyList);
173 pfDao.deleteCollection(emptyKeyList);
174 pfDao.delete(PfConceptKey.class, nullKey);
175 pfDao.delete(PfReferenceKey.class, nullRefKey);
176 pfDao.delete(PfTimestampKey.class, nullTimeKey);
177 pfDao.deleteByConceptKey(PfConceptKey.class, nullKeyList);
178 pfDao.deleteByConceptKey(PfConceptKey.class, emptyKeyList);
179 pfDao.deleteByReferenceKey(PfReferenceKey.class, nullRKeyList);
180 pfDao.deleteByReferenceKey(PfReferenceKey.class, emptyRKeyList);
182 pfDao.get(null, nullKey);
183 pfDao.get(null, nullRefKey);
184 pfDao.get(null, nullTimeKey);
186 pfDao.getAll(null, nullKey);
187 pfDao.getAll(null, null, null);
188 pfDao.getConcept(null, nullKey);
189 pfDao.getConcept(PfConceptKey.class, nullKey);
190 pfDao.getConcept(null, nullRefKey);
191 pfDao.getConcept(PfReferenceKey.class, nullRefKey);
193 assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
196 private void testAllOps() {
197 final PfConceptKey aKey0 = new PfConceptKey("A-KEY0", VERSION001);
198 final PfConceptKey aKey1 = new PfConceptKey("A-KEY1", VERSION001);
199 final PfConceptKey aKey2 = new PfConceptKey("A-KEY2", VERSION001);
200 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
201 UUID.fromString(UUID0), DESCRIPTION0);
202 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
203 UUID.fromString(UUID1), DESCRIPTION1);
204 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
205 UUID.fromString(UUID2), DESCRIPTION2);
207 pfDao.create(keyInfo0);
209 final DummyConceptEntity keyInfoBack0 = pfDao.get(DummyConceptEntity.class, aKey0);
210 assertEquals(keyInfo0, keyInfoBack0);
212 final DummyConceptEntity keyInfoBackNull = pfDao.get(DummyConceptEntity.class, PfConceptKey.getNullKey());
213 assertNull(keyInfoBackNull);
215 final DummyConceptEntity keyInfoBack1 = pfDao.getConcept(DummyConceptEntity.class, aKey0);
216 assertEquals(keyInfoBack0, keyInfoBack1);
218 final DummyConceptEntity keyInfoBack2 =
219 pfDao.getConcept(DummyConceptEntity.class, new PfConceptKey("A-KEY3", VERSION001));
220 assertNull(keyInfoBack2);
222 final Set<DummyConceptEntity> keyInfoSetIn = new TreeSet<>();
223 keyInfoSetIn.add(keyInfo1);
224 keyInfoSetIn.add(keyInfo2);
226 pfDao.createCollection(keyInfoSetIn);
228 Set<DummyConceptEntity> keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
230 keyInfoSetIn.add(keyInfo0);
231 assertEquals(keyInfoSetIn, keyInfoSetOut);
233 pfDao.delete(keyInfo1);
234 keyInfoSetIn.remove(keyInfo1);
235 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
236 assertEquals(keyInfoSetIn, keyInfoSetOut);
238 pfDao.deleteCollection(keyInfoSetIn);
239 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
240 assertEquals(0, keyInfoSetOut.size());
242 keyInfoSetIn.add(keyInfo0);
243 keyInfoSetIn.add(keyInfo1);
244 keyInfoSetIn.add(keyInfo0);
245 pfDao.createCollection(keyInfoSetIn);
246 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
247 assertEquals(keyInfoSetIn, keyInfoSetOut);
249 pfDao.delete(DummyConceptEntity.class, aKey0);
250 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
251 assertEquals(2, keyInfoSetOut.size());
252 assertEquals(2, pfDao.size(DummyConceptEntity.class));
254 final Set<PfConceptKey> keySetIn = new TreeSet<>();
258 final int deletedCount = pfDao.deleteByConceptKey(DummyConceptEntity.class, keySetIn);
259 assertEquals(2, deletedCount);
261 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
262 assertEquals(0, keyInfoSetOut.size());
264 keyInfoSetIn.add(keyInfo0);
265 keyInfoSetIn.add(keyInfo1);
266 keyInfoSetIn.add(keyInfo0);
267 pfDao.createCollection(keyInfoSetIn);
268 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
269 assertEquals(keyInfoSetIn, keyInfoSetOut);
271 pfDao.deleteAll(DummyConceptEntity.class);
272 assertEquals(0, pfDao.size(DummyConceptEntity.class));
274 final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
275 final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
276 final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
277 final PfConceptKey owner3Key = new PfConceptKey("Owner3", VERSION001);
278 final PfConceptKey owner4Key = new PfConceptKey("Owner4", VERSION001);
279 final PfConceptKey owner5Key = new PfConceptKey("Owner5", VERSION001);
281 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, ENTITY0), 100.0));
282 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity1"), 101.0));
283 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity2"), 102.0));
284 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity3"), 103.0));
285 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity4"), 104.0));
286 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity5"), 105.0));
287 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity6"), 106.0));
288 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity7"), 107.0));
289 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity8"), 108.0));
290 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity9"), 109.0));
291 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner3Key, "EntityA"), 110.0));
292 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner4Key, "EntityB"), 111.0));
293 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityC"), 112.0));
294 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityD"), 113.0));
295 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityE"), 114.0));
296 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 115.0));
298 TreeSet<DummyReferenceEntity> testEntitySetOut =
299 new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class));
300 assertEquals(16, testEntitySetOut.size());
302 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner0Key));
303 assertEquals(5, testEntitySetOut.size());
305 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner1Key));
306 assertEquals(3, testEntitySetOut.size());
308 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner2Key));
309 assertEquals(2, testEntitySetOut.size());
311 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner3Key));
312 assertEquals(1, testEntitySetOut.size());
314 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner4Key));
315 assertEquals(1, testEntitySetOut.size());
317 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner5Key));
318 assertEquals(4, testEntitySetOut.size());
320 assertNotNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
321 assertNotNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
322 assertNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
323 assertNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
324 pfDao.delete(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0));
326 final Set<PfReferenceKey> rKeySetIn = new TreeSet<>();
327 rKeySetIn.add(new PfReferenceKey(owner4Key, "EntityB"));
328 rKeySetIn.add(new PfReferenceKey(owner5Key, "EntityD"));
330 final int deletedRCount = pfDao.deleteByReferenceKey(DummyReferenceEntity.class, rKeySetIn);
331 assertEquals(2, deletedRCount);
333 pfDao.update(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 120.0));
335 final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
336 final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
337 final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
338 final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
339 final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
340 final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
342 pfDao.create(tkeyInfo0);
344 final DummyTimestampEntity tkeyInfoBack0 = pfDao.get(DummyTimestampEntity.class, atKey0);
345 assertEquals(tkeyInfo0, tkeyInfoBack0);
347 final DummyTimestampEntity tkeyInfoBackNull =
348 pfDao.get(DummyTimestampEntity.class, PfTimestampKey.getNullKey());
349 assertNull(tkeyInfoBackNull);
353 final Set<DummyTimestampEntity> tkeyInfoSetIn = new TreeSet<>();
354 tkeyInfoSetIn.add(tkeyInfo1);
355 tkeyInfoSetIn.add(tkeyInfo2);
357 pfDao.createCollection(tkeyInfoSetIn);
359 Set<DummyTimestampEntity> tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
361 tkeyInfoSetIn.add(tkeyInfo0);
362 assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
364 pfDao.delete(tkeyInfo1);
365 tkeyInfoSetIn.remove(tkeyInfo1);
366 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
367 assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
369 pfDao.deleteCollection(tkeyInfoSetIn);
370 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
371 assertEquals(0, tkeyInfoSetOut.size());
373 tkeyInfoSetIn.add(tkeyInfo2);
374 pfDao.createCollection(tkeyInfoSetIn);
375 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
376 assertEquals(keyInfoSetIn, keyInfoSetOut);
378 pfDao.delete(DummyTimestampEntity.class, atKey2);
379 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
380 assertEquals(3, keyInfoSetOut.size());
381 assertEquals(1, pfDao.size(DummyTimestampEntity.class));
383 pfDao.deleteAll(DummyTimestampEntity.class);
384 assertEquals(0, pfDao.size(DummyTimestampEntity.class));
387 private void testGeneratedId() {
388 final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001, GENERATEDID0);
389 final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001, GENERATEDID1);
390 final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001, GENERATEDID2);
391 final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0));
392 final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1));
393 final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2));
395 pfDao.create(gkeyInfo0);
397 final DummyGeneratedIdEntity gkeyInfoBack0 = pfDao.get(DummyGeneratedIdEntity.class, agKey0);
398 assertEquals(gkeyInfo0, gkeyInfoBack0);
400 assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey0, TIMESTAMP0).size());
402 final DummyGeneratedIdEntity gkeyInfoBackNull =
403 pfDao.get(DummyGeneratedIdEntity.class, PfGeneratedIdKey.getNullKey());
404 assertNull(gkeyInfoBackNull);
406 final Set<DummyGeneratedIdEntity> gkeyInfoSetIn = new TreeSet<>();
407 gkeyInfoSetIn.add(gkeyInfo1);
408 gkeyInfoSetIn.add(gkeyInfo2);
410 pfDao.createCollection(gkeyInfoSetIn);
412 Set<DummyGeneratedIdEntity> gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
414 gkeyInfoSetIn.add(gkeyInfo0);
415 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
417 pfDao.delete(gkeyInfo1);
418 gkeyInfoSetIn.remove(gkeyInfo1);
419 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
420 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
422 pfDao.deleteCollection(gkeyInfoSetIn);
423 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
424 assertEquals(0, gkeyInfoSetOut.size());
426 gkeyInfoSetIn.add(gkeyInfo2);
427 pfDao.createCollection(gkeyInfoSetIn);
428 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
429 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
431 pfDao.delete(DummyGeneratedIdEntity.class, agKey2);
432 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
433 assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
435 pfDao.deleteAll(DummyGeneratedIdEntity.class);
436 assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
438 final PfGeneratedIdKey agKey3 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
439 final PfGeneratedIdKey agKey4 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
440 final PfGeneratedIdKey agKey5 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
441 final DummyGeneratedIdEntity gkeyInfo3 = new DummyGeneratedIdEntity(agKey3, Date.from(TIMESTAMP0));
442 final DummyGeneratedIdEntity gkeyInfo4 = new DummyGeneratedIdEntity(agKey4, Date.from(TIMESTAMP1));
443 final DummyGeneratedIdEntity gkeyInfo5 = new DummyGeneratedIdEntity(agKey5, Date.from(TIMESTAMP2));
445 pfDao.create(gkeyInfo3);
447 final DummyGeneratedIdEntity gkeyInfoBack3 = pfDao.get(DummyGeneratedIdEntity.class, agKey3);
448 assertEquals(gkeyInfo3, gkeyInfoBack3);
450 assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey3, TIMESTAMP0).size());
452 assertEquals(1, gkeyInfo3.getKeys().size());
454 assertEquals(1, gkeyInfo4.compareTo(gkeyInfo3));
456 assertNull(gkeyInfo4.validate(VERSION002).getResult());
459 gkeyInfoSetIn.clear();
460 gkeyInfoSetIn.add(gkeyInfo4);
461 gkeyInfoSetIn.add(gkeyInfo5);
463 pfDao.createCollection(gkeyInfoSetIn);
465 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
467 gkeyInfoSetIn.add(gkeyInfo3);
468 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
470 pfDao.delete(gkeyInfo4);
471 gkeyInfoSetIn.remove(gkeyInfo4);
472 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
473 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
475 pfDao.deleteCollection(gkeyInfoSetIn);
476 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
477 assertEquals(0, gkeyInfoSetOut.size());
479 gkeyInfoSetIn.add(gkeyInfo5);
480 pfDao.createCollection(gkeyInfoSetIn);
481 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
482 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
484 pfDao.delete(DummyGeneratedIdEntity.class, agKey5);
485 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
486 assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
488 pfDao.deleteAll(DummyGeneratedIdEntity.class);
489 assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
492 private void testReferenceTimestamp() {
493 final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
494 final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
495 final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
496 final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
497 final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
498 final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
499 final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
500 final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
501 final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
503 pfDao.create(rkeyInfo0);
505 final DummyReferenceTimestampEntity rkeyInfoBack0 = pfDao.get(DummyReferenceTimestampEntity.class, arKey0);
506 assertEquals(rkeyInfo0, rkeyInfoBack0);
509 final DummyReferenceTimestampEntity rkeyInfoBackNull =
510 pfDao.get(DummyReferenceTimestampEntity.class, PfReferenceTimestampKey.getNullKey());
511 assertNull(rkeyInfoBackNull);
513 final Set<DummyReferenceTimestampEntity> rkeyInfoSetIn = new TreeSet<>();
514 rkeyInfoSetIn.add(rkeyInfo1);
515 rkeyInfoSetIn.add(rkeyInfo2);
517 pfDao.createCollection(rkeyInfoSetIn);
519 Set<DummyReferenceTimestampEntity> rkeyInfoSetOut =
520 new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
522 rkeyInfoSetIn.add(rkeyInfo0);
523 assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
525 pfDao.delete(rkeyInfo1);
526 rkeyInfoSetIn.remove(rkeyInfo1);
527 rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
528 assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
530 pfDao.deleteCollection(rkeyInfoSetIn);
531 rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
532 assertEquals(0, rkeyInfoSetOut.size());
534 rkeyInfoSetIn.add(rkeyInfo2);
535 pfDao.createCollection(rkeyInfoSetIn);
536 rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
537 assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
539 pfDao.deleteAll(DummyReferenceTimestampEntity.class);
540 assertEquals(0, pfDao.size(DummyReferenceTimestampEntity.class));
543 private void testVersionOps() {
544 final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
545 final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
546 final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
547 final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
548 final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
549 final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
550 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
551 UUID.fromString(UUID0), DESCRIPTION0);
552 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
553 UUID.fromString(UUID1), DESCRIPTION1);
554 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
555 UUID.fromString(UUID2), DESCRIPTION2);
556 final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
557 UUID.fromString(UUID0), DESCRIPTION0);
558 final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
559 UUID.fromString(UUID1), DESCRIPTION1);
560 final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
561 UUID.fromString(UUID2), DESCRIPTION2);
563 pfDao.create(keyInfo0);
564 pfDao.create(keyInfo1);
565 pfDao.create(keyInfo2);
566 pfDao.create(keyInfo3);
567 pfDao.create(keyInfo4);
568 pfDao.create(keyInfo5);
570 assertEquals(3, pfDao.getAllVersions(DummyConceptEntity.class, "AAA0").size());
571 assertEquals(0, pfDao.getAllVersions(null, "AAA0").size());
572 assertEquals(0, pfDao.getAllVersions(DummyConceptEntity.class, null).size());
575 private void testgetFilteredOps() {
576 final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
577 final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
578 final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
579 final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
580 final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
581 final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
582 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
583 UUID.fromString(UUID0), DESCRIPTION0);
584 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
585 UUID.fromString(UUID1), DESCRIPTION1);
586 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
587 UUID.fromString(UUID2), DESCRIPTION2);
588 final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
589 UUID.fromString(UUID0), DESCRIPTION0);
590 final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
591 UUID.fromString(UUID1), DESCRIPTION1);
592 final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
593 UUID.fromString(UUID2), DESCRIPTION2);
595 pfDao.create(keyInfo0);
596 pfDao.create(keyInfo1);
597 pfDao.create(keyInfo2);
598 pfDao.create(keyInfo3);
599 pfDao.create(keyInfo4);
600 pfDao.create(keyInfo5);
602 assertThat(pfDao.getFiltered(DummyConceptEntity.class, null, null)).hasSize(6);
603 assertThat(pfDao.getFiltered(DummyConceptEntity.class, "AAA0", null)).hasSize(3);
604 assertThat(pfDao.getFiltered(DummyConceptEntity.class, "BBB0", null)).hasSize(3);
605 assertThat(pfDao.getFiltered(DummyConceptEntity.class, "BBB0", VERSION003)).hasSize(1);
606 assertThat(pfDao.getFiltered(DummyConceptEntity.class, null, VERSION003)).hasSize(6);
608 final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
609 final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
610 final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
611 final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
612 final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
613 final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
615 pfDao.create(tkeyInfo0);
616 pfDao.create(tkeyInfo1);
617 pfDao.create(tkeyInfo2);
620 assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
621 PfFilterParameters.builder().name("AT-KEY0").version(VERSION001).build())).hasSize(1);
622 assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().name("AT-KEY0").build()))
624 assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().version(VERSION001)
625 .startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
626 assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().name("AT-KEY0")
627 .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
628 assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
629 PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
630 assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
631 PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
632 assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().version(VERSION001)
633 .startTime(TIMESTAMP0).endTime(TIMESTAMP2).sortOrder("DESC").recordNum(2).build())).hasSize(2);
635 Map<String, Object> filterMap = new HashMap<>();
636 filterMap.put("doubleValue", 200.1);
637 assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
638 PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);
641 private void testgetFilteredOps2() {
642 Map<String, Object> filterMap = new HashMap<>();
643 filterMap.put("doubleValue", 200.1);
645 final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
646 final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
647 final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
648 final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0), 200.0);
649 final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1), 200.1);
650 final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2), 200.2);
652 pfDao.create(gkeyInfo0);
653 pfDao.create(gkeyInfo1);
654 pfDao.create(gkeyInfo2);
657 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
658 PfFilterParameters.builder().name("AT-KEY0").version(VERSION001).build())).hasSize(1);
659 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
660 PfFilterParameters.builder().name("AT-KEY0").build())).hasSize(1);
661 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class, PfFilterParameters.builder().version(VERSION001)
662 .startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
663 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class, PfFilterParameters.builder().name("AT-KEY0")
664 .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
665 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
666 PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
667 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
668 PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
669 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class, PfFilterParameters.builder().version(VERSION001)
670 .startTime(TIMESTAMP0).endTime(TIMESTAMP2).sortOrder("DESC").recordNum(2).build())).hasSize(2);
672 assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
673 PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);
676 private void testgetFilteredOps3() {
677 Map<String, Object> filterMap = new HashMap<>();
678 filterMap.put("localName", "AT-KEY0");
680 final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
681 final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
682 final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
683 final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
684 final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
685 final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
686 final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
687 final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
688 final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
690 pfDao.create(rkeyInfo0);
691 pfDao.create(rkeyInfo1);
692 pfDao.create(rkeyInfo2);
695 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
696 PfFilterParameters.builder().name("Owner0").version(VERSION001).build())).hasSize(1);
697 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
698 PfFilterParameters.builder().name("Owner0").build())).hasSize(1);
699 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class, PfFilterParameters.builder()
700 .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
701 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class, PfFilterParameters.builder().name("Owner0")
702 .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
703 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
704 PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
705 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
706 PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
707 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
708 PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2)
709 .sortOrder("DESC").recordNum(2).build())).hasSize(2);
711 assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
712 PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);