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.PfTimestampKey;
48 import org.onap.policy.models.dao.impl.DefaultPfDao;
53 public class EntityTest {
54 private static final String DESCRIPTION2 = "key description 2";
55 private static final String DESCRIPTION1 = "key description 1";
56 private static final String DESCRIPTION0 = "key description 0";
57 private static final String ENTITY0 = "Entity0";
58 private static final String UUID2 = "00000000-0000-0000-0000-000000000002";
59 private static final String UUID1 = "00000000-0000-0000-0000-000000000001";
60 private static final String UUID0 = "00000000-0000-0000-0000-000000000000";
61 private static final String VERSION003 = "0.0.3";
62 private static final String VERSION002 = "0.0.2";
63 private static final String VERSION001 = "0.0.1";
64 private static final Instant TIMESTAMP0 = Instant.ofEpochSecond(1613494293);
65 private static final Instant TIMESTAMP1 = Instant.ofEpochSecond(1613494293).plusSeconds(55);
66 private static final Instant TIMESTAMP2 = Instant.ofEpochSecond(1613494293).plusSeconds(90);
67 private static final Long GENERATEDID0 = 10000L;
68 private static final Long GENERATEDID1 = 10001L;
69 private static final Long GENERATEDID2 = 10002L;
77 public void tearDown() {
85 public void testEntityTestSanity() throws PfModelException {
86 final DaoParameters daoParameters = new DaoParameters();
88 Properties jdbcProperties = new Properties();
90 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER, "org.h2.Driver");
91 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL, "jdbc:h2:mem:EntityTest");
92 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER, "sa");
93 jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "");
96 daoParameters.setJdbcProperties(jdbcProperties);
98 pfDao = new PfDaoFactory().createPfDao(daoParameters);
100 assertThatThrownBy(() -> pfDao.init(null)).hasMessage("Policy Framework persistence unit parameter not set");
102 assertThatThrownBy(() -> pfDao.init(daoParameters))
103 .hasMessage("Policy Framework persistence unit parameter not set");
105 daoParameters.setPluginClass("somewhere.over.the.rainbow");
106 daoParameters.setPersistenceUnit("Dorothy");
108 assertThatThrownBy(() -> pfDao.init(daoParameters))
109 .hasMessage("Creation of Policy Framework persistence unit \"Dorothy\" failed");
111 assertThatThrownBy(() -> pfDao.create(new PfConceptKey()))
112 .hasMessage("Policy Framework DAO has not been initialized");
116 public void testEntityTestAllOpsJpa() throws PfModelException {
118 final DaoParameters daoParameters = new DaoParameters();
119 daoParameters.setPluginClass(DefaultPfDao.class.getName());
120 daoParameters.setPersistenceUnit("DaoTest");
122 Properties jdbcProperties = new Properties();
123 jdbcProperties.setProperty("javax.persistence.jdbc.driver", "org.h2.Driver");
124 jdbcProperties.setProperty("javax.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
125 jdbcProperties.setProperty("javax.persistence.jdbc.user", "sa");
126 jdbcProperties.setProperty("javax.persistence.jdbc.password", "");
128 daoParameters.setJdbcProperties(jdbcProperties);
130 pfDao = new PfDaoFactory().createPfDao(daoParameters);
131 pfDao.init(daoParameters);
139 testgetFilteredOps();
141 testgetFilteredOps2();
145 public void testEntityTestBadVals() throws PfModelException {
146 final DaoParameters daoParameters = new DaoParameters();
147 daoParameters.setPluginClass(DefaultPfDao.class.getName());
148 daoParameters.setPersistenceUnit("DaoTest");
150 pfDao = new PfDaoFactory().createPfDao(daoParameters);
151 pfDao.init(daoParameters);
153 final PfConceptKey nullKey = null;
154 final PfReferenceKey nullRefKey = null;
155 final PfTimestampKey nullTimeKey = null;
156 final List<PfConceptKey> nullKeyList = null;
157 final List<PfConceptKey> emptyKeyList = new ArrayList<>();
158 final List<PfReferenceKey> nullRKeyList = null;
159 final List<PfReferenceKey> emptyRKeyList = new ArrayList<>();
161 pfDao.create(nullKey);
162 pfDao.createCollection(nullKeyList);
163 pfDao.createCollection(emptyKeyList);
165 pfDao.delete(nullKey);
166 pfDao.deleteCollection(nullKeyList);
167 pfDao.deleteCollection(emptyKeyList);
168 pfDao.delete(PfConceptKey.class, nullKey);
169 pfDao.delete(PfReferenceKey.class, nullRefKey);
170 pfDao.delete(PfTimestampKey.class, nullTimeKey);
171 pfDao.deleteByConceptKey(PfConceptKey.class, nullKeyList);
172 pfDao.deleteByConceptKey(PfConceptKey.class, emptyKeyList);
173 pfDao.deleteByReferenceKey(PfReferenceKey.class, nullRKeyList);
174 pfDao.deleteByReferenceKey(PfReferenceKey.class, emptyRKeyList);
176 pfDao.get(null, nullKey);
177 pfDao.get(null, nullRefKey);
178 pfDao.get(null, nullTimeKey);
180 pfDao.getAll(null, nullKey);
181 pfDao.getConcept(null, nullKey);
182 pfDao.getConcept(PfConceptKey.class, nullKey);
183 pfDao.getConcept(null, nullRefKey);
184 pfDao.getConcept(PfReferenceKey.class, nullRefKey);
186 assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
189 private void testAllOps() {
190 final PfConceptKey aKey0 = new PfConceptKey("A-KEY0", VERSION001);
191 final PfConceptKey aKey1 = new PfConceptKey("A-KEY1", VERSION001);
192 final PfConceptKey aKey2 = new PfConceptKey("A-KEY2", VERSION001);
193 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
194 UUID.fromString(UUID0), DESCRIPTION0);
195 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
196 UUID.fromString(UUID1), DESCRIPTION1);
197 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
198 UUID.fromString(UUID2), DESCRIPTION2);
200 pfDao.create(keyInfo0);
202 final DummyConceptEntity keyInfoBack0 = pfDao.get(DummyConceptEntity.class, aKey0);
203 assertEquals(keyInfo0, keyInfoBack0);
205 final DummyConceptEntity keyInfoBackNull = pfDao.get(DummyConceptEntity.class, PfConceptKey.getNullKey());
206 assertNull(keyInfoBackNull);
208 final DummyConceptEntity keyInfoBack1 = pfDao.getConcept(DummyConceptEntity.class, aKey0);
209 assertEquals(keyInfoBack0, keyInfoBack1);
211 final DummyConceptEntity keyInfoBack2 =
212 pfDao.getConcept(DummyConceptEntity.class, new PfConceptKey("A-KEY3", VERSION001));
213 assertNull(keyInfoBack2);
215 final Set<DummyConceptEntity> keyInfoSetIn = new TreeSet<>();
216 keyInfoSetIn.add(keyInfo1);
217 keyInfoSetIn.add(keyInfo2);
219 pfDao.createCollection(keyInfoSetIn);
221 Set<DummyConceptEntity> keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
223 keyInfoSetIn.add(keyInfo0);
224 assertEquals(keyInfoSetIn, keyInfoSetOut);
226 pfDao.delete(keyInfo1);
227 keyInfoSetIn.remove(keyInfo1);
228 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
229 assertEquals(keyInfoSetIn, keyInfoSetOut);
231 pfDao.deleteCollection(keyInfoSetIn);
232 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
233 assertEquals(0, keyInfoSetOut.size());
235 keyInfoSetIn.add(keyInfo0);
236 keyInfoSetIn.add(keyInfo1);
237 keyInfoSetIn.add(keyInfo0);
238 pfDao.createCollection(keyInfoSetIn);
239 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
240 assertEquals(keyInfoSetIn, keyInfoSetOut);
242 pfDao.delete(DummyConceptEntity.class, aKey0);
243 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
244 assertEquals(2, keyInfoSetOut.size());
245 assertEquals(2, pfDao.size(DummyConceptEntity.class));
247 final Set<PfConceptKey> keySetIn = new TreeSet<>();
251 final int deletedCount = pfDao.deleteByConceptKey(DummyConceptEntity.class, keySetIn);
252 assertEquals(2, deletedCount);
254 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
255 assertEquals(0, keyInfoSetOut.size());
257 keyInfoSetIn.add(keyInfo0);
258 keyInfoSetIn.add(keyInfo1);
259 keyInfoSetIn.add(keyInfo0);
260 pfDao.createCollection(keyInfoSetIn);
261 keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
262 assertEquals(keyInfoSetIn, keyInfoSetOut);
264 pfDao.deleteAll(DummyConceptEntity.class);
265 assertEquals(0, pfDao.size(DummyConceptEntity.class));
267 final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
268 final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
269 final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
270 final PfConceptKey owner3Key = new PfConceptKey("Owner3", VERSION001);
271 final PfConceptKey owner4Key = new PfConceptKey("Owner4", VERSION001);
272 final PfConceptKey owner5Key = new PfConceptKey("Owner5", VERSION001);
274 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, ENTITY0), 100.0));
275 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity1"), 101.0));
276 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity2"), 102.0));
277 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity3"), 103.0));
278 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity4"), 104.0));
279 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity5"), 105.0));
280 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity6"), 106.0));
281 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity7"), 107.0));
282 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity8"), 108.0));
283 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity9"), 109.0));
284 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner3Key, "EntityA"), 110.0));
285 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner4Key, "EntityB"), 111.0));
286 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityC"), 112.0));
287 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityD"), 113.0));
288 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityE"), 114.0));
289 pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 115.0));
291 TreeSet<DummyReferenceEntity> testEntitySetOut =
292 new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class));
293 assertEquals(16, testEntitySetOut.size());
295 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner0Key));
296 assertEquals(5, testEntitySetOut.size());
298 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner1Key));
299 assertEquals(3, testEntitySetOut.size());
301 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner2Key));
302 assertEquals(2, testEntitySetOut.size());
304 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner3Key));
305 assertEquals(1, testEntitySetOut.size());
307 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner4Key));
308 assertEquals(1, testEntitySetOut.size());
310 testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner5Key));
311 assertEquals(4, testEntitySetOut.size());
313 assertNotNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
314 assertNotNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
315 assertNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
316 assertNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
317 pfDao.delete(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0));
319 final Set<PfReferenceKey> rKeySetIn = new TreeSet<>();
320 rKeySetIn.add(new PfReferenceKey(owner4Key, "EntityB"));
321 rKeySetIn.add(new PfReferenceKey(owner5Key, "EntityD"));
323 final int deletedRCount = pfDao.deleteByReferenceKey(DummyReferenceEntity.class, rKeySetIn);
324 assertEquals(2, deletedRCount);
326 pfDao.update(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 120.0));
328 final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
329 final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
330 final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
331 final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
332 final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
333 final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
335 pfDao.create(tkeyInfo0);
337 final DummyTimestampEntity tkeyInfoBack0 = pfDao.get(DummyTimestampEntity.class, atKey0);
338 assertEquals(tkeyInfo0, tkeyInfoBack0);
340 final DummyTimestampEntity tkeyInfoBackNull =
341 pfDao.get(DummyTimestampEntity.class, PfTimestampKey.getNullKey());
342 assertNull(tkeyInfoBackNull);
346 final Set<DummyTimestampEntity> tkeyInfoSetIn = new TreeSet<>();
347 tkeyInfoSetIn.add(tkeyInfo1);
348 tkeyInfoSetIn.add(tkeyInfo2);
350 pfDao.createCollection(tkeyInfoSetIn);
352 Set<DummyTimestampEntity> tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
354 tkeyInfoSetIn.add(tkeyInfo0);
355 assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
357 pfDao.delete(tkeyInfo1);
358 tkeyInfoSetIn.remove(tkeyInfo1);
359 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
360 assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
362 pfDao.deleteCollection(tkeyInfoSetIn);
363 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
364 assertEquals(0, tkeyInfoSetOut.size());
366 tkeyInfoSetIn.add(tkeyInfo2);
367 pfDao.createCollection(tkeyInfoSetIn);
368 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
369 assertEquals(keyInfoSetIn, keyInfoSetOut);
371 pfDao.delete(DummyTimestampEntity.class, atKey2);
372 tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
373 assertEquals(3, keyInfoSetOut.size());
374 assertEquals(1, pfDao.size(DummyTimestampEntity.class));
376 pfDao.deleteAll(DummyTimestampEntity.class);
377 assertEquals(0, pfDao.size(DummyTimestampEntity.class));
380 private void testGeneratedId() {
381 final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001, GENERATEDID0);
382 final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001, GENERATEDID1);
383 final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001, GENERATEDID2);
384 final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0));
385 final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1));
386 final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2));
388 pfDao.create(gkeyInfo0);
390 final DummyGeneratedIdEntity gkeyInfoBack0 = pfDao.get(DummyGeneratedIdEntity.class, agKey0);
391 assertEquals(gkeyInfo0, gkeyInfoBack0);
393 assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey0, TIMESTAMP0).size());
395 final DummyGeneratedIdEntity gkeyInfoBackNull =
396 pfDao.get(DummyGeneratedIdEntity.class, PfGeneratedIdKey.getNullKey());
397 assertNull(gkeyInfoBackNull);
399 final Set<DummyGeneratedIdEntity> gkeyInfoSetIn = new TreeSet<>();
400 gkeyInfoSetIn.add(gkeyInfo1);
401 gkeyInfoSetIn.add(gkeyInfo2);
403 pfDao.createCollection(gkeyInfoSetIn);
405 Set<DummyGeneratedIdEntity> gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
407 gkeyInfoSetIn.add(gkeyInfo0);
408 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
410 pfDao.delete(gkeyInfo1);
411 gkeyInfoSetIn.remove(gkeyInfo1);
412 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
413 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
415 pfDao.deleteCollection(gkeyInfoSetIn);
416 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
417 assertEquals(0, gkeyInfoSetOut.size());
419 gkeyInfoSetIn.add(gkeyInfo2);
420 pfDao.createCollection(gkeyInfoSetIn);
421 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
422 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
424 pfDao.delete(DummyGeneratedIdEntity.class, agKey2);
425 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
426 assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
428 pfDao.deleteAll(DummyGeneratedIdEntity.class);
429 assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
431 final PfGeneratedIdKey agKey3 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
432 final PfGeneratedIdKey agKey4 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
433 final PfGeneratedIdKey agKey5 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
434 final DummyGeneratedIdEntity gkeyInfo3 = new DummyGeneratedIdEntity(agKey3, Date.from(TIMESTAMP0));
435 final DummyGeneratedIdEntity gkeyInfo4 = new DummyGeneratedIdEntity(agKey4, Date.from(TIMESTAMP1));
436 final DummyGeneratedIdEntity gkeyInfo5 = new DummyGeneratedIdEntity(agKey5, Date.from(TIMESTAMP2));
438 pfDao.create(gkeyInfo3);
440 final DummyGeneratedIdEntity gkeyInfoBack3 = pfDao.get(DummyGeneratedIdEntity.class, agKey3);
441 assertEquals(gkeyInfo3, gkeyInfoBack3);
443 assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey3, TIMESTAMP0).size());
445 assertEquals(1, gkeyInfo3.getKeys().size());
447 assertEquals(1, gkeyInfo4.compareTo(gkeyInfo3));
449 assertNull(gkeyInfo4.validate(VERSION002).getResult());
452 gkeyInfoSetIn.clear();
453 gkeyInfoSetIn.add(gkeyInfo4);
454 gkeyInfoSetIn.add(gkeyInfo5);
456 pfDao.createCollection(gkeyInfoSetIn);
458 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
460 gkeyInfoSetIn.add(gkeyInfo3);
461 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
463 pfDao.delete(gkeyInfo4);
464 gkeyInfoSetIn.remove(gkeyInfo4);
465 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
466 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
468 pfDao.deleteCollection(gkeyInfoSetIn);
469 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
470 assertEquals(0, gkeyInfoSetOut.size());
472 gkeyInfoSetIn.add(gkeyInfo5);
473 pfDao.createCollection(gkeyInfoSetIn);
474 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
475 assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
477 pfDao.delete(DummyGeneratedIdEntity.class, agKey5);
478 gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
479 assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
481 pfDao.deleteAll(DummyGeneratedIdEntity.class);
482 assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
485 private void testVersionOps() {
486 final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
487 final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
488 final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
489 final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
490 final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
491 final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
492 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
493 UUID.fromString(UUID0), DESCRIPTION0);
494 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
495 UUID.fromString(UUID1), DESCRIPTION1);
496 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
497 UUID.fromString(UUID2), DESCRIPTION2);
498 final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
499 UUID.fromString(UUID0), DESCRIPTION0);
500 final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
501 UUID.fromString(UUID1), DESCRIPTION1);
502 final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
503 UUID.fromString(UUID2), DESCRIPTION2);
505 pfDao.create(keyInfo0);
506 pfDao.create(keyInfo1);
507 pfDao.create(keyInfo2);
508 pfDao.create(keyInfo3);
509 pfDao.create(keyInfo4);
510 pfDao.create(keyInfo5);
512 assertEquals(3, pfDao.getAllVersions(DummyConceptEntity.class, "AAA0").size());
513 assertEquals(0, pfDao.getAllVersions(null, "AAA0").size());
514 assertEquals(0, pfDao.getAllVersions(DummyConceptEntity.class, null).size());
517 private void testgetFilteredOps() {
518 final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
519 final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
520 final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
521 final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
522 final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
523 final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
524 final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
525 UUID.fromString(UUID0), DESCRIPTION0);
526 final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
527 UUID.fromString(UUID1), DESCRIPTION1);
528 final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
529 UUID.fromString(UUID2), DESCRIPTION2);
530 final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
531 UUID.fromString(UUID0), DESCRIPTION0);
532 final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
533 UUID.fromString(UUID1), DESCRIPTION1);
534 final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
535 UUID.fromString(UUID2), DESCRIPTION2);
537 pfDao.create(keyInfo0);
538 pfDao.create(keyInfo1);
539 pfDao.create(keyInfo2);
540 pfDao.create(keyInfo3);
541 pfDao.create(keyInfo4);
542 pfDao.create(keyInfo5);
544 assertEquals(6, pfDao.getFiltered(DummyConceptEntity.class, null, null).size());
545 assertEquals(3, pfDao.getFiltered(DummyConceptEntity.class, "AAA0", null).size());
546 assertEquals(3, pfDao.getFiltered(DummyConceptEntity.class, "BBB0", null).size());
547 assertEquals(1, pfDao.getFiltered(DummyConceptEntity.class, "BBB0", VERSION003).size());
548 assertEquals(6, pfDao.getFiltered(DummyConceptEntity.class, null, VERSION003).size());
550 final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
551 final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
552 final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
553 final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
554 final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
555 final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
557 pfDao.create(tkeyInfo0);
558 pfDao.create(tkeyInfo1);
559 pfDao.create(tkeyInfo2);
562 assertEquals(1, pfDao
563 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
565 pfDao.getFiltered(DummyTimestampEntity.class, "AT-KEY0", null, null, null, null, "DESC", 0).size());
566 assertEquals(3, pfDao
567 .getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
569 assertEquals(1, pfDao
570 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
572 assertEquals(3, pfDao
573 .getFiltered(DummyTimestampEntity.class, null, VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
574 assertEquals(3, pfDao
575 .getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, null, null, "DESC", 0).size());
577 pfDao.getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
580 Map<String, Object> filterMap = new HashMap<>();
581 filterMap.put("doubleValue", 200.1);
583 pfDao.getFiltered(DummyTimestampEntity.class, null, null, null, null, filterMap, "DESC", 0).size());
586 private void testgetFilteredOps2() {
587 Map<String, Object> filterMap = new HashMap<>();
588 filterMap.put("doubleValue", 200.1);
590 final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
591 final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
592 final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
593 final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0), 200.0);
594 final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1), 200.1);
595 final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2), 200.2);
597 pfDao.create(gkeyInfo0);
598 pfDao.create(gkeyInfo1);
599 pfDao.create(gkeyInfo2);
602 assertEquals(1, pfDao
603 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
605 pfDao.getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", null, null, null, null, "DESC", 0).size());
606 assertEquals(3, pfDao
607 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
609 assertEquals(1, pfDao
610 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001,
611 TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
613 assertEquals(3, pfDao
614 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
615 assertEquals(3, pfDao
616 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001,
617 TIMESTAMP0, null, null, "DESC", 0).size());
619 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, VERSION001,
620 TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
624 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, null, null, null, filterMap, "DESC", 0).size());