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.assertThatCode;
25 import static org.assertj.core.api.Assertions.assertThatThrownBy;
26 import static org.junit.Assert.assertEquals;
27 import static org.junit.Assert.assertNotNull;
28 import static org.junit.Assert.assertNull;
30 import java.time.Instant;
31 import java.util.ArrayList;
32 import java.util.Date;
33 import java.util.HashMap;
34 import java.util.List;
36 import java.util.Properties;
38 import java.util.TreeSet;
39 import java.util.UUID;
40 import org.eclipse.persistence.config.PersistenceUnitProperties;
41 import org.junit.After;
42 import org.junit.Test;
43 import org.onap.policy.models.base.PfConceptKey;
44 import org.onap.policy.models.base.PfGeneratedIdKey;
45 import org.onap.policy.models.base.PfModelException;
46 import org.onap.policy.models.base.PfReferenceKey;
47 import org.onap.policy.models.base.PfReferenceTimestampKey;
48 import org.onap.policy.models.base.PfTimestampKey;
49 import org.onap.policy.models.dao.impl.DefaultPfDao;
54 public class EntityTest {
55 private static final String DESCRIPTION2 = "key description 2";
56 private static final String DESCRIPTION1 = "key description 1";
57 private static final String DESCRIPTION0 = "key description 0";
58 private static final String ENTITY0 = "Entity0";
59 private static final String UUID2 = "00000000-0000-0000-0000-000000000002";
60 private static final String UUID1 = "00000000-0000-0000-0000-000000000001";
61 private static final String UUID0 = "00000000-0000-0000-0000-000000000000";
62 private static final String VERSION003 = "0.0.3";
63 private static final String VERSION002 = "0.0.2";
64 private static final String VERSION001 = "0.0.1";
65 private static final Instant TIMESTAMP0 = Instant.ofEpochSecond(1613494293);
66 private static final Instant TIMESTAMP1 = Instant.ofEpochSecond(1613494293).plusSeconds(55);
67 private static final Instant TIMESTAMP2 = Instant.ofEpochSecond(1613494293).plusSeconds(90);
68 private static final Long GENERATEDID0 = 10000L;
69 private static final Long GENERATEDID1 = 10001L;
70 private static final Long GENERATEDID2 = 10002L;
78 public void tearDown() {
86 public void testEntityTestSanity() throws PfModelException {
87 final DaoParameters daoParameters = new DaoParameters();
89 Properties jdbcProperties = new Properties();
91 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
92 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:EntityTest");
93 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "sa");
94 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "");
97 daoParameters.setJdbcProperties(jdbcProperties);
99 pfDao = new PfDaoFactory().createPfDao(daoParameters);
101 assertThatThrownBy(() -> pfDao.init(null)).hasMessage("Policy Framework persistence unit parameter not set");
103 assertThatThrownBy(() -> pfDao.init(daoParameters))
104 .hasMessage("Policy Framework persistence unit parameter not set");
106 daoParameters.setPluginClass("somewhere.over.the.rainbow");
107 daoParameters.setPersistenceUnit("Dorothy");
109 assertThatThrownBy(() -> pfDao.init(daoParameters))
110 .hasMessage("Creation of Policy Framework persistence unit \"Dorothy\" failed");
112 assertThatThrownBy(() -> pfDao.create(new PfConceptKey()))
113 .hasMessage("Policy Framework DAO has not been initialized");
117 public void testEntityTestAllOpsJpa() throws PfModelException {
119 final DaoParameters daoParameters = new DaoParameters();
120 daoParameters.setPluginClass(DefaultPfDao.class.getName());
121 daoParameters.setPersistenceUnit("DaoTest");
123 Properties jdbcProperties = new Properties();
124 jdbcProperties.setProperty("javax.persistence.jdbc.driver", "org.h2.Driver");
125 jdbcProperties.setProperty("javax.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
126 jdbcProperties.setProperty("javax.persistence.jdbc.user", "sa");
127 jdbcProperties.setProperty("javax.persistence.jdbc.password", "");
129 daoParameters.setJdbcProperties(jdbcProperties);
131 pfDao = new PfDaoFactory().createPfDao(daoParameters);
132 pfDao.init(daoParameters);
138 testReferenceTimestamp();
142 testgetFilteredOps();
144 testgetFilteredOps2();
146 testgetFilteredOps3();
150 public void testEntityTestBadVals() throws PfModelException {
151 final DaoParameters daoParameters = new DaoParameters();
152 daoParameters.setPluginClass(DefaultPfDao.class.getName());
153 daoParameters.setPersistenceUnit("DaoTest");
155 pfDao = new PfDaoFactory().createPfDao(daoParameters);
156 pfDao.init(daoParameters);
158 final PfConceptKey nullKey = null;
159 final PfReferenceKey nullRefKey = null;
160 final PfTimestampKey nullTimeKey = null;
161 final List<PfConceptKey> nullKeyList = null;
162 final List<PfConceptKey> emptyKeyList = new ArrayList<>();
163 final List<PfReferenceKey> nullRKeyList = null;
164 final List<PfReferenceKey> emptyRKeyList = new ArrayList<>();
166 pfDao.create(nullKey);
167 pfDao.createCollection(nullKeyList);
168 pfDao.createCollection(emptyKeyList);
170 pfDao.delete(nullKey);
171 pfDao.deleteCollection(nullKeyList);
172 pfDao.deleteCollection(emptyKeyList);
173 pfDao.delete(PfConceptKey.class, nullKey);
174 pfDao.delete(PfReferenceKey.class, nullRefKey);
175 pfDao.delete(PfTimestampKey.class, nullTimeKey);
176 pfDao.deleteByConceptKey(PfConceptKey.class, nullKeyList);
177 pfDao.deleteByConceptKey(PfConceptKey.class, emptyKeyList);
178 pfDao.deleteByReferenceKey(PfReferenceKey.class, nullRKeyList);
179 pfDao.deleteByReferenceKey(PfReferenceKey.class, emptyRKeyList);
181 pfDao.get(null, nullKey);
182 pfDao.get(null, nullRefKey);
183 pfDao.get(null, nullTimeKey);
185 pfDao.getAll(null, nullKey);
186 pfDao.getAll(null, null, null);
187 pfDao.getConcept(null, nullKey);
188 pfDao.getConcept(PfConceptKey.class, nullKey);
189 pfDao.getConcept(null, nullRefKey);
190 pfDao.getConcept(PfReferenceKey.class, nullRefKey);
192 assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
195 private void testAllOps() {
196 final PfConceptKey aKey0 = new PfConceptKey("A-KEY0", VERSION001);
197 final PfConceptKey aKey1 = new PfConceptKey("A-KEY1", VERSION001);
198 final PfConceptKey aKey2 = new PfConceptKey("A-KEY2", VERSION001);
199 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
200 UUID.fromString(UUID0), DESCRIPTION0);
201 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
202 UUID.fromString(UUID1), DESCRIPTION1);
203 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
204 UUID.fromString(UUID2), DESCRIPTION2);
206 pfDao.create(keyInfo0);
208 final DummyConceptEntity keyInfoBack0 = pfDao.get(DummyConceptEntity.class, aKey0);
209 assertEquals(keyInfo0, keyInfoBack0);
211 final DummyConceptEntity keyInfoBackNull = pfDao.get(DummyConceptEntity.class, PfConceptKey.getNullKey());
212 assertNull(keyInfoBackNull);
214 final DummyConceptEntity keyInfoBack1 = pfDao.getConcept(DummyConceptEntity.class, aKey0);
215 assertEquals(keyInfoBack0, keyInfoBack1);
217 final DummyConceptEntity keyInfoBack2 =
218 pfDao.getConcept(DummyConceptEntity.class, new PfConceptKey("A-KEY3", VERSION001));
219 assertNull(keyInfoBack2);
221 final Set<DummyConceptEntity> keyInfoSetIn = new TreeSet<>();
222 keyInfoSetIn.add(keyInfo1);
223 keyInfoSetIn.add(keyInfo2);
225 pfDao.createCollection(keyInfoSetIn);
227 Set<DummyConceptEntity> keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
229 keyInfoSetIn.add(keyInfo0);
230 assertEquals(keyInfoSetIn, keyInfoSetOut);
232 pfDao.delete(keyInfo1);
233 keyInfoSetIn.remove(keyInfo1);
234 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
235 assertEquals(keyInfoSetIn, keyInfoSetOut);
237 pfDao.deleteCollection(keyInfoSetIn);
238 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
239 assertEquals(0, keyInfoSetOut.size());
241 keyInfoSetIn.add(keyInfo0);
242 keyInfoSetIn.add(keyInfo1);
243 keyInfoSetIn.add(keyInfo0);
244 pfDao.createCollection(keyInfoSetIn);
245 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
246 assertEquals(keyInfoSetIn, keyInfoSetOut);
248 pfDao.delete(DummyConceptEntity.class, aKey0);
249 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
250 assertEquals(2, keyInfoSetOut.size());
251 assertEquals(2, pfDao.size(DummyConceptEntity.class));
253 final Set<PfConceptKey> keySetIn = new TreeSet<>();
257 final int deletedCount = pfDao.deleteByConceptKey(DummyConceptEntity.class, keySetIn);
258 assertEquals(2, deletedCount);
260 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
261 assertEquals(0, keyInfoSetOut.size());
263 keyInfoSetIn.add(keyInfo0);
264 keyInfoSetIn.add(keyInfo1);
265 keyInfoSetIn.add(keyInfo0);
266 pfDao.createCollection(keyInfoSetIn);
267 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
268 assertEquals(keyInfoSetIn, keyInfoSetOut);
270 pfDao.deleteAll(DummyConceptEntity.class);
271 assertEquals(0, pfDao.size(DummyConceptEntity.class));
273 final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
274 final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
275 final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
276 final PfConceptKey owner3Key = new PfConceptKey("Owner3", VERSION001);
277 final PfConceptKey owner4Key = new PfConceptKey("Owner4", VERSION001);
278 final PfConceptKey owner5Key = new PfConceptKey("Owner5", VERSION001);
280 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, ENTITY0), 100.0));
281 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity1"), 101.0));
282 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity2"), 102.0));
283 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity3"), 103.0));
284 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity4"), 104.0));
285 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity5"), 105.0));
286 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity6"), 106.0));
287 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity7"), 107.0));
288 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity8"), 108.0));
289 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity9"), 109.0));
290 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner3Key, "EntityA"), 110.0));
291 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner4Key, "EntityB"), 111.0));
292 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityC"), 112.0));
293 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityD"), 113.0));
294 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityE"), 114.0));
295 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 115.0));
297 TreeSet<DummyReferenceEntity> testEntitySetOut =
298 new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class));
299 assertEquals(16, testEntitySetOut.size());
301 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner0Key));
302 assertEquals(5, testEntitySetOut.size());
304 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner1Key));
305 assertEquals(3, testEntitySetOut.size());
307 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner2Key));
308 assertEquals(2, testEntitySetOut.size());
310 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner3Key));
311 assertEquals(1, testEntitySetOut.size());
313 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner4Key));
314 assertEquals(1, testEntitySetOut.size());
316 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner5Key));
317 assertEquals(4, testEntitySetOut.size());
319 assertNotNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
320 assertNotNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
321 assertNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
322 assertNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
323 pfDao.delete(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0));
325 final Set<PfReferenceKey> rKeySetIn = new TreeSet<>();
326 rKeySetIn.add(new PfReferenceKey(owner4Key, "EntityB"));
327 rKeySetIn.add(new PfReferenceKey(owner5Key, "EntityD"));
329 final int deletedRCount = pfDao.deleteByReferenceKey(DummyReferenceEntity.class, rKeySetIn);
330 assertEquals(2, deletedRCount);
332 pfDao.update(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 120.0));
334 final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
335 final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
336 final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
337 final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
338 final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
339 final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
341 pfDao.create(tkeyInfo0);
343 final DummyTimestampEntity tkeyInfoBack0 = pfDao.get(DummyTimestampEntity.class, atKey0);
344 assertEquals(tkeyInfo0, tkeyInfoBack0);
346 final DummyTimestampEntity tkeyInfoBackNull =
347 pfDao.get(DummyTimestampEntity.class, PfTimestampKey.getNullKey());
348 assertNull(tkeyInfoBackNull);
352 final Set<DummyTimestampEntity> tkeyInfoSetIn = new TreeSet<>();
353 tkeyInfoSetIn.add(tkeyInfo1);
354 tkeyInfoSetIn.add(tkeyInfo2);
356 pfDao.createCollection(tkeyInfoSetIn);
358 Set<DummyTimestampEntity> tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
360 tkeyInfoSetIn.add(tkeyInfo0);
361 assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
363 pfDao.delete(tkeyInfo1);
364 tkeyInfoSetIn.remove(tkeyInfo1);
365 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
366 assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
368 pfDao.deleteCollection(tkeyInfoSetIn);
369 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
370 assertEquals(0, tkeyInfoSetOut.size());
372 tkeyInfoSetIn.add(tkeyInfo2);
373 pfDao.createCollection(tkeyInfoSetIn);
374 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
375 assertEquals(keyInfoSetIn, keyInfoSetOut);
377 pfDao.delete(DummyTimestampEntity.class, atKey2);
378 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
379 assertEquals(3, keyInfoSetOut.size());
380 assertEquals(1, pfDao.size(DummyTimestampEntity.class));
382 pfDao.deleteAll(DummyTimestampEntity.class);
383 assertEquals(0, pfDao.size(DummyTimestampEntity.class));
386 private void testGeneratedId() {
387 final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001, GENERATEDID0);
388 final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001, GENERATEDID1);
389 final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001, GENERATEDID2);
390 final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0));
391 final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1));
392 final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2));
394 pfDao.create(gkeyInfo0);
396 final DummyGeneratedIdEntity gkeyInfoBack0 = pfDao.get(DummyGeneratedIdEntity.class, agKey0);
397 assertEquals(gkeyInfo0, gkeyInfoBack0);
399 assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey0, TIMESTAMP0).size());
401 final DummyGeneratedIdEntity gkeyInfoBackNull =
402 pfDao.get(DummyGeneratedIdEntity.class, PfGeneratedIdKey.getNullKey());
403 assertNull(gkeyInfoBackNull);
405 final Set<DummyGeneratedIdEntity> gkeyInfoSetIn = new TreeSet<>();
406 gkeyInfoSetIn.add(gkeyInfo1);
407 gkeyInfoSetIn.add(gkeyInfo2);
409 pfDao.createCollection(gkeyInfoSetIn);
411 Set<DummyGeneratedIdEntity> gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
413 gkeyInfoSetIn.add(gkeyInfo0);
414 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
416 pfDao.delete(gkeyInfo1);
417 gkeyInfoSetIn.remove(gkeyInfo1);
418 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
419 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
421 pfDao.deleteCollection(gkeyInfoSetIn);
422 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
423 assertEquals(0, gkeyInfoSetOut.size());
425 gkeyInfoSetIn.add(gkeyInfo2);
426 pfDao.createCollection(gkeyInfoSetIn);
427 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
428 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
430 pfDao.delete(DummyGeneratedIdEntity.class, agKey2);
431 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
432 assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
434 pfDao.deleteAll(DummyGeneratedIdEntity.class);
435 assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
437 final PfGeneratedIdKey agKey3 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
438 final PfGeneratedIdKey agKey4 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
439 final PfGeneratedIdKey agKey5 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
440 final DummyGeneratedIdEntity gkeyInfo3 = new DummyGeneratedIdEntity(agKey3, Date.from(TIMESTAMP0));
441 final DummyGeneratedIdEntity gkeyInfo4 = new DummyGeneratedIdEntity(agKey4, Date.from(TIMESTAMP1));
442 final DummyGeneratedIdEntity gkeyInfo5 = new DummyGeneratedIdEntity(agKey5, Date.from(TIMESTAMP2));
444 pfDao.create(gkeyInfo3);
446 final DummyGeneratedIdEntity gkeyInfoBack3 = pfDao.get(DummyGeneratedIdEntity.class, agKey3);
447 assertEquals(gkeyInfo3, gkeyInfoBack3);
449 assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey3, TIMESTAMP0).size());
451 assertEquals(1, gkeyInfo3.getKeys().size());
453 assertEquals(1, gkeyInfo4.compareTo(gkeyInfo3));
455 assertNull(gkeyInfo4.validate(VERSION002).getResult());
458 gkeyInfoSetIn.clear();
459 gkeyInfoSetIn.add(gkeyInfo4);
460 gkeyInfoSetIn.add(gkeyInfo5);
462 pfDao.createCollection(gkeyInfoSetIn);
464 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
466 gkeyInfoSetIn.add(gkeyInfo3);
467 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
469 pfDao.delete(gkeyInfo4);
470 gkeyInfoSetIn.remove(gkeyInfo4);
471 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
472 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
474 pfDao.deleteCollection(gkeyInfoSetIn);
475 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
476 assertEquals(0, gkeyInfoSetOut.size());
478 gkeyInfoSetIn.add(gkeyInfo5);
479 pfDao.createCollection(gkeyInfoSetIn);
480 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
481 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
483 pfDao.delete(DummyGeneratedIdEntity.class, agKey5);
484 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
485 assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
487 pfDao.deleteAll(DummyGeneratedIdEntity.class);
488 assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
491 private void testReferenceTimestamp() {
492 final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
493 final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
494 final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
495 final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
496 final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
497 final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
498 final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
499 final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
500 final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
502 pfDao.create(rkeyInfo0);
504 final DummyReferenceTimestampEntity rkeyInfoBack0 = pfDao.get(DummyReferenceTimestampEntity.class, arKey0);
505 assertEquals(rkeyInfo0, rkeyInfoBack0);
508 final DummyReferenceTimestampEntity rkeyInfoBackNull =
509 pfDao.get(DummyReferenceTimestampEntity.class, PfReferenceTimestampKey.getNullKey());
510 assertNull(rkeyInfoBackNull);
512 final Set<DummyReferenceTimestampEntity> rkeyInfoSetIn = new TreeSet<>();
513 rkeyInfoSetIn.add(rkeyInfo1);
514 rkeyInfoSetIn.add(rkeyInfo2);
516 pfDao.createCollection(rkeyInfoSetIn);
518 Set<DummyReferenceTimestampEntity> rkeyInfoSetOut =
519 new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
521 rkeyInfoSetIn.add(rkeyInfo0);
522 assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
524 pfDao.delete(rkeyInfo1);
525 rkeyInfoSetIn.remove(rkeyInfo1);
526 rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
527 assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
529 pfDao.deleteCollection(rkeyInfoSetIn);
530 rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
531 assertEquals(0, rkeyInfoSetOut.size());
533 rkeyInfoSetIn.add(rkeyInfo2);
534 pfDao.createCollection(rkeyInfoSetIn);
535 rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
536 assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
538 pfDao.deleteAll(DummyReferenceTimestampEntity.class);
539 assertEquals(0, pfDao.size(DummyReferenceTimestampEntity.class));
542 private void testVersionOps() {
543 final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
544 final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
545 final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
546 final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
547 final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
548 final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
549 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
550 UUID.fromString(UUID0), DESCRIPTION0);
551 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
552 UUID.fromString(UUID1), DESCRIPTION1);
553 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
554 UUID.fromString(UUID2), DESCRIPTION2);
555 final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
556 UUID.fromString(UUID0), DESCRIPTION0);
557 final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
558 UUID.fromString(UUID1), DESCRIPTION1);
559 final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
560 UUID.fromString(UUID2), DESCRIPTION2);
562 pfDao.create(keyInfo0);
563 pfDao.create(keyInfo1);
564 pfDao.create(keyInfo2);
565 pfDao.create(keyInfo3);
566 pfDao.create(keyInfo4);
567 pfDao.create(keyInfo5);
569 assertEquals(3, pfDao.getAllVersions(DummyConceptEntity.class, "AAA0").size());
570 assertEquals(0, pfDao.getAllVersions(null, "AAA0").size());
571 assertEquals(0, pfDao.getAllVersions(DummyConceptEntity.class, null).size());
574 private void testgetFilteredOps() {
575 final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
576 final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
577 final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
578 final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
579 final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
580 final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
581 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
582 UUID.fromString(UUID0), DESCRIPTION0);
583 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
584 UUID.fromString(UUID1), DESCRIPTION1);
585 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
586 UUID.fromString(UUID2), DESCRIPTION2);
587 final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
588 UUID.fromString(UUID0), DESCRIPTION0);
589 final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
590 UUID.fromString(UUID1), DESCRIPTION1);
591 final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
592 UUID.fromString(UUID2), DESCRIPTION2);
594 pfDao.create(keyInfo0);
595 pfDao.create(keyInfo1);
596 pfDao.create(keyInfo2);
597 pfDao.create(keyInfo3);
598 pfDao.create(keyInfo4);
599 pfDao.create(keyInfo5);
601 assertEquals(6, pfDao.getFiltered(DummyConceptEntity.class, null, null).size());
602 assertEquals(3, pfDao.getFiltered(DummyConceptEntity.class, "AAA0", null).size());
603 assertEquals(3, pfDao.getFiltered(DummyConceptEntity.class, "BBB0", null).size());
604 assertEquals(1, pfDao.getFiltered(DummyConceptEntity.class, "BBB0", VERSION003).size());
605 assertEquals(6, pfDao.getFiltered(DummyConceptEntity.class, null, VERSION003).size());
607 final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
608 final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
609 final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
610 final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
611 final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
612 final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
614 pfDao.create(tkeyInfo0);
615 pfDao.create(tkeyInfo1);
616 pfDao.create(tkeyInfo2);
619 assertEquals(1, pfDao
620 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
622 pfDao.getFiltered(DummyTimestampEntity.class, "AT-KEY0", null, null, null, null, "DESC", 0).size());
623 assertEquals(3, pfDao
624 .getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
626 assertEquals(1, pfDao
627 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
629 assertEquals(3, pfDao
630 .getFiltered(DummyTimestampEntity.class, null, VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
631 assertEquals(3, pfDao
632 .getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, null, null, "DESC", 0).size());
634 pfDao.getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
637 Map<String, Object> filterMap = new HashMap<>();
638 filterMap.put("doubleValue", 200.1);
640 pfDao.getFiltered(DummyTimestampEntity.class, null, null, null, null, filterMap, "DESC", 0).size());
643 private void testgetFilteredOps2() {
644 Map<String, Object> filterMap = new HashMap<>();
645 filterMap.put("doubleValue", 200.1);
647 final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
648 final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
649 final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
650 final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0), 200.0);
651 final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1), 200.1);
652 final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2), 200.2);
654 pfDao.create(gkeyInfo0);
655 pfDao.create(gkeyInfo1);
656 pfDao.create(gkeyInfo2);
659 assertEquals(1, pfDao
660 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
662 pfDao.getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", null, null, null, null, "DESC", 0).size());
663 assertEquals(3, pfDao
664 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
666 assertEquals(1, pfDao
667 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001,
668 TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
670 assertEquals(3, pfDao
671 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
672 assertEquals(3, pfDao
673 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001,
674 TIMESTAMP0, null, null, "DESC", 0).size());
676 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, VERSION001,
677 TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
681 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, null, null, null, filterMap, "DESC", 0).size());
684 private void testgetFilteredOps3() {
685 Map<String, Object> filterMap = new HashMap<>();
686 filterMap.put("localName", "AT-KEY0");
688 final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
689 final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
690 final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
691 final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
692 final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
693 final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
694 final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
695 final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
696 final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
698 pfDao.create(rkeyInfo0);
699 pfDao.create(rkeyInfo1);
700 pfDao.create(rkeyInfo2);
703 assertEquals(1, pfDao
704 .getFiltered(DummyReferenceTimestampEntity.class,
705 "Owner0", VERSION001, null, null, null, "DESC", 0).size());
707 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
708 "Owner0", null, null, null, null, "DESC", 0).size());
709 assertEquals(3, pfDao
710 .getFiltered(DummyReferenceTimestampEntity.class,
711 null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
713 assertEquals(1, pfDao
714 .getFiltered(DummyReferenceTimestampEntity.class,
715 "Owner0", VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
717 assertEquals(3, pfDao
718 .getFiltered(DummyReferenceTimestampEntity.class, null,
719 VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
720 assertEquals(3, pfDao
721 .getFiltered(DummyReferenceTimestampEntity.class, null,
722 VERSION001, TIMESTAMP0, null, null, "DESC", 0).size());
724 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
725 null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
729 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
730 null, null, null, null, filterMap, "DESC", 0).size());