models-dao/src/test/java/org/onap/policy/models/dao/EntityTest.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2019-2021 Nordix Foundation.
   4  *  Modifications Copyright (C) 2019-2021 AT&T Intellectual Property. All rights reserved.
   5  *  Modifications Copyright (C) 2022 Bell Canada. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  * SPDX-License-Identifier: Apache-2.0
  20  * ============LICENSE_END=========================================================
  21  */
  22
  23 package org.onap.policy.models.dao;
  24
  25 import static org.assertj.core.api.Assertions.assertThat;
  26 import static org.assertj.core.api.Assertions.assertThatCode;
  27 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  28 import static org.junit.Assert.assertEquals;
  29 import static org.junit.Assert.assertNotNull;
  30 import static org.junit.Assert.assertNull;
  31
  32 import java.time.Instant;
  33 import java.util.ArrayList;
  34 import java.util.HashMap;
  35 import java.util.List;
  36 import java.util.Map;
  37 import java.util.Properties;
  38 import java.util.Set;
  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.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;
  50
  51 /**
  52  * JUnit test class.
  53  */
  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
  69     private PfDao pfDao;
  70
  71     /**
  72      * Closes the DAO.
  73      */
  74     @After
  75     public void tearDown() {
  76         if (pfDao != null) {
  77             pfDao.close();
  78             pfDao = null;
  79         }
  80     }
  81
  82     @Test
  83     public void testEntityTestSanity() throws PfModelException {
  84         final DaoParameters daoParameters = new DaoParameters();
  85
  86         Properties jdbcProperties = new Properties();
  87         // @formatter:off
  88         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER,   "org.h2.Driver");
  89         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL,      "jdbc:h2:mem:EntityTest");
  90         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER,     "sa");
  91         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "");
  92         // @formatter:on
  93
  94         daoParameters.setJdbcProperties(jdbcProperties);
  95
  96         pfDao = new PfDaoFactory().createPfDao(daoParameters);
  97
  98         assertThatThrownBy(() -> pfDao.init(null)).hasMessage("Policy Framework persistence unit parameter not set");
  99
 100         assertThatThrownBy(() -> pfDao.init(daoParameters))
 101                         .hasMessage("Policy Framework persistence unit parameter not set");
 102
 103         daoParameters.setPluginClass("somewhere.over.the.rainbow");
 104         daoParameters.setPersistenceUnit("Dorothy");
 105
 106         assertThatThrownBy(() -> pfDao.init(daoParameters))
 107                         .hasMessage("Creation of Policy Framework persistence unit \"Dorothy\" failed");
 108
 109         assertThatThrownBy(() -> pfDao.create(new PfConceptKey()))
 110                         .hasMessage("Policy Framework DAO has not been initialized");
 111     }
 112
 113     @Test
 114     public void testEntityTestAllOpsJpa() throws PfModelException {
 115
 116         final DaoParameters daoParameters = new DaoParameters();
 117         daoParameters.setPluginClass(DefaultPfDao.class.getName());
 118         daoParameters.setPersistenceUnit("DaoTest");
 119
 120         Properties jdbcProperties = new Properties();
 121         jdbcProperties.setProperty("javax.persistence.jdbc.driver", "org.h2.Driver");
 122         jdbcProperties.setProperty("javax.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
 123         jdbcProperties.setProperty("javax.persistence.jdbc.user", "sa");
 124         jdbcProperties.setProperty("javax.persistence.jdbc.password", "");
 125
 126         daoParameters.setJdbcProperties(jdbcProperties);
 127
 128         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 129         pfDao.init(daoParameters);
 130
 131         testAllOps();
 132
 133         testReferenceTimestamp();
 134
 135         testVersionOps();
 136
 137         testgetFilteredOps();
 138
 139         testgetFilteredOps3();
 140     }
 141
 142     @Test
 143     public void testEntityTestBadVals() throws PfModelException {
 144         final DaoParameters daoParameters = new DaoParameters();
 145         daoParameters.setPluginClass(DefaultPfDao.class.getName());
 146         daoParameters.setPersistenceUnit("DaoTest");
 147
 148         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 149         pfDao.init(daoParameters);
 150
 151         final PfConceptKey nullKey = null;
 152         final PfReferenceKey nullRefKey = null;
 153         final PfTimestampKey nullTimeKey = null;
 154         final List<PfConceptKey> nullKeyList = null;
 155         final List<PfConceptKey> emptyKeyList = new ArrayList<>();
 156         final List<PfReferenceKey> nullRKeyList = null;
 157         final List<PfReferenceKey> emptyRKeyList = new ArrayList<>();
 158
 159         pfDao.create(nullKey);
 160         pfDao.createCollection(nullKeyList);
 161         pfDao.createCollection(emptyKeyList);
 162
 163         pfDao.delete(nullKey);
 164         pfDao.deleteCollection(nullKeyList);
 165         pfDao.deleteCollection(emptyKeyList);
 166         pfDao.delete(PfConceptKey.class, nullKey);
 167         pfDao.delete(PfReferenceKey.class, nullRefKey);
 168         pfDao.delete(PfTimestampKey.class, nullTimeKey);
 169         pfDao.deleteByConceptKey(PfConceptKey.class, nullKeyList);
 170         pfDao.deleteByConceptKey(PfConceptKey.class, emptyKeyList);
 171         pfDao.deleteByReferenceKey(PfReferenceKey.class, nullRKeyList);
 172         pfDao.deleteByReferenceKey(PfReferenceKey.class, emptyRKeyList);
 173
 174         pfDao.get(null, nullKey);
 175         pfDao.get(null, nullRefKey);
 176         pfDao.get(null, nullTimeKey);
 177         pfDao.getAll(null);
 178         pfDao.getAll(null, nullKey);
 179         pfDao.getAll(null, null, null);
 180         pfDao.getConcept(null, nullKey);
 181         pfDao.getConcept(PfConceptKey.class, nullKey);
 182         pfDao.getConcept(null, nullRefKey);
 183         pfDao.getConcept(PfReferenceKey.class, nullRefKey);
 184
 185         assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
 186     }
 187
 188     private void testAllOps() {
 189         final PfConceptKey aKey0 = new PfConceptKey("A-KEY0", VERSION001);
 190         final PfConceptKey aKey1 = new PfConceptKey("A-KEY1", VERSION001);
 191         final PfConceptKey aKey2 = new PfConceptKey("A-KEY2", VERSION001);
 192         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 193                 UUID.fromString(UUID0), DESCRIPTION0);
 194         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 195                 UUID.fromString(UUID1), DESCRIPTION1);
 196         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 197                 UUID.fromString(UUID2), DESCRIPTION2);
 198
 199         pfDao.create(keyInfo0);
 200
 201         final DummyConceptEntity keyInfoBack0 = pfDao.get(DummyConceptEntity.class, aKey0);
 202         assertEquals(keyInfo0, keyInfoBack0);
 203
 204         final DummyConceptEntity keyInfoBackNull = pfDao.get(DummyConceptEntity.class, PfConceptKey.getNullKey());
 205         assertNull(keyInfoBackNull);
 206
 207         final DummyConceptEntity keyInfoBack1 = pfDao.getConcept(DummyConceptEntity.class, aKey0);
 208         assertEquals(keyInfoBack0, keyInfoBack1);
 209
 210         final DummyConceptEntity keyInfoBack2 =
 211                 pfDao.getConcept(DummyConceptEntity.class, new PfConceptKey("A-KEY3", VERSION001));
 212         assertNull(keyInfoBack2);
 213
 214         final Set<DummyConceptEntity> keyInfoSetIn = new TreeSet<>();
 215         keyInfoSetIn.add(keyInfo1);
 216         keyInfoSetIn.add(keyInfo2);
 217
 218         pfDao.createCollection(keyInfoSetIn);
 219
 220         Set<DummyConceptEntity> keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 221
 222         keyInfoSetIn.add(keyInfo0);
 223         assertEquals(keyInfoSetIn, keyInfoSetOut);
 224
 225         pfDao.delete(keyInfo1);
 226         keyInfoSetIn.remove(keyInfo1);
 227         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 228         assertEquals(keyInfoSetIn, keyInfoSetOut);
 229
 230         pfDao.deleteCollection(keyInfoSetIn);
 231         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 232         assertEquals(0, keyInfoSetOut.size());
 233
 234         keyInfoSetIn.add(keyInfo0);
 235         keyInfoSetIn.add(keyInfo1);
 236         keyInfoSetIn.add(keyInfo0);
 237         pfDao.createCollection(keyInfoSetIn);
 238         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 239         assertEquals(keyInfoSetIn, keyInfoSetOut);
 240
 241         pfDao.delete(DummyConceptEntity.class, aKey0);
 242         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 243         assertEquals(2, keyInfoSetOut.size());
 244         assertEquals(2, pfDao.size(DummyConceptEntity.class));
 245
 246         final Set<PfConceptKey> keySetIn = new TreeSet<>();
 247         keySetIn.add(aKey1);
 248         keySetIn.add(aKey2);
 249
 250         final int deletedCount = pfDao.deleteByConceptKey(DummyConceptEntity.class, keySetIn);
 251         assertEquals(2, deletedCount);
 252
 253         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 254         assertEquals(0, keyInfoSetOut.size());
 255
 256         keyInfoSetIn.add(keyInfo0);
 257         keyInfoSetIn.add(keyInfo1);
 258         keyInfoSetIn.add(keyInfo0);
 259         pfDao.createCollection(keyInfoSetIn);
 260         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 261         assertEquals(keyInfoSetIn, keyInfoSetOut);
 262
 263         pfDao.deleteAll(DummyConceptEntity.class);
 264         assertEquals(0, pfDao.size(DummyConceptEntity.class));
 265
 266         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 267         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 268         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 269         final PfConceptKey owner3Key = new PfConceptKey("Owner3", VERSION001);
 270         final PfConceptKey owner4Key = new PfConceptKey("Owner4", VERSION001);
 271         final PfConceptKey owner5Key = new PfConceptKey("Owner5", VERSION001);
 272
 273         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, ENTITY0), 100.0));
 274         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity1"), 101.0));
 275         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity2"), 102.0));
 276         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity3"), 103.0));
 277         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity4"), 104.0));
 278         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity5"), 105.0));
 279         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity6"), 106.0));
 280         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity7"), 107.0));
 281         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity8"), 108.0));
 282         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity9"), 109.0));
 283         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner3Key, "EntityA"), 110.0));
 284         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner4Key, "EntityB"), 111.0));
 285         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityC"), 112.0));
 286         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityD"), 113.0));
 287         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityE"), 114.0));
 288         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 115.0));
 289
 290         TreeSet<DummyReferenceEntity> testEntitySetOut =
 291                 new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class));
 292         assertEquals(16, testEntitySetOut.size());
 293
 294         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner0Key));
 295         assertEquals(5, testEntitySetOut.size());
 296
 297         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner1Key));
 298         assertEquals(3, testEntitySetOut.size());
 299
 300         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner2Key));
 301         assertEquals(2, testEntitySetOut.size());
 302
 303         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner3Key));
 304         assertEquals(1, testEntitySetOut.size());
 305
 306         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner4Key));
 307         assertEquals(1, testEntitySetOut.size());
 308
 309         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner5Key));
 310         assertEquals(4, testEntitySetOut.size());
 311
 312         assertNotNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
 313         assertNotNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
 314         assertNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
 315         assertNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
 316         pfDao.delete(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0));
 317
 318         final Set<PfReferenceKey> rKeySetIn = new TreeSet<>();
 319         rKeySetIn.add(new PfReferenceKey(owner4Key, "EntityB"));
 320         rKeySetIn.add(new PfReferenceKey(owner5Key, "EntityD"));
 321
 322         final int deletedRCount = pfDao.deleteByReferenceKey(DummyReferenceEntity.class, rKeySetIn);
 323         assertEquals(2, deletedRCount);
 324
 325         pfDao.update(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 120.0));
 326
 327         final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
 328         final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
 329         final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
 330         final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
 331         final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
 332         final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
 333
 334         pfDao.create(tkeyInfo0);
 335
 336         final DummyTimestampEntity tkeyInfoBack0 = pfDao.get(DummyTimestampEntity.class, atKey0);
 337         assertEquals(tkeyInfo0, tkeyInfoBack0);
 338
 339         final DummyTimestampEntity tkeyInfoBackNull =
 340                 pfDao.get(DummyTimestampEntity.class, PfTimestampKey.getNullKey());
 341         assertNull(tkeyInfoBackNull);
 342
 343
 344
 345         final Set<DummyTimestampEntity> tkeyInfoSetIn = new TreeSet<>();
 346         tkeyInfoSetIn.add(tkeyInfo1);
 347         tkeyInfoSetIn.add(tkeyInfo2);
 348
 349         pfDao.createCollection(tkeyInfoSetIn);
 350
 351         Set<DummyTimestampEntity> tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 352
 353         tkeyInfoSetIn.add(tkeyInfo0);
 354         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 355
 356         pfDao.delete(tkeyInfo1);
 357         tkeyInfoSetIn.remove(tkeyInfo1);
 358         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 359         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 360
 361         pfDao.deleteCollection(tkeyInfoSetIn);
 362         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 363         assertEquals(0, tkeyInfoSetOut.size());
 364
 365         tkeyInfoSetIn.add(tkeyInfo2);
 366         pfDao.createCollection(tkeyInfoSetIn);
 367         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 368         assertEquals(keyInfoSetIn, keyInfoSetOut);
 369
 370         pfDao.delete(DummyTimestampEntity.class, atKey2);
 371         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 372         assertEquals(3, keyInfoSetOut.size());
 373         assertEquals(1, pfDao.size(DummyTimestampEntity.class));
 374
 375         pfDao.deleteAll(DummyTimestampEntity.class);
 376         assertEquals(0, pfDao.size(DummyTimestampEntity.class));
 377     }
 378
 379     private void testReferenceTimestamp() {
 380         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 381         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 382         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 383         final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
 384         final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
 385         final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
 386         final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
 387         final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
 388         final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
 389
 390         pfDao.create(rkeyInfo0);
 391
 392         final  DummyReferenceTimestampEntity rkeyInfoBack0 = pfDao.get(DummyReferenceTimestampEntity.class, arKey0);
 393         assertEquals(rkeyInfo0, rkeyInfoBack0);
 394
 395
 396         final DummyReferenceTimestampEntity rkeyInfoBackNull =
 397                 pfDao.get(DummyReferenceTimestampEntity.class, PfReferenceTimestampKey.getNullKey());
 398         assertNull(rkeyInfoBackNull);
 399
 400         final Set<DummyReferenceTimestampEntity> rkeyInfoSetIn = new TreeSet<>();
 401         rkeyInfoSetIn.add(rkeyInfo1);
 402         rkeyInfoSetIn.add(rkeyInfo2);
 403
 404         pfDao.createCollection(rkeyInfoSetIn);
 405
 406         Set<DummyReferenceTimestampEntity> rkeyInfoSetOut =
 407                 new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 408
 409         rkeyInfoSetIn.add(rkeyInfo0);
 410         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 411
 412         pfDao.delete(rkeyInfo1);
 413         rkeyInfoSetIn.remove(rkeyInfo1);
 414         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 415         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 416
 417         pfDao.deleteCollection(rkeyInfoSetIn);
 418         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 419         assertEquals(0, rkeyInfoSetOut.size());
 420
 421         rkeyInfoSetIn.add(rkeyInfo2);
 422         pfDao.createCollection(rkeyInfoSetIn);
 423         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 424         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 425
 426         pfDao.deleteAll(DummyReferenceTimestampEntity.class);
 427         assertEquals(0, pfDao.size(DummyReferenceTimestampEntity.class));
 428     }
 429
 430     private void testVersionOps() {
 431         final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
 432         final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
 433         final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
 434         final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
 435         final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
 436         final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
 437         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 438                 UUID.fromString(UUID0), DESCRIPTION0);
 439         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 440                 UUID.fromString(UUID1), DESCRIPTION1);
 441         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 442                 UUID.fromString(UUID2), DESCRIPTION2);
 443         final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
 444                 UUID.fromString(UUID0), DESCRIPTION0);
 445         final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
 446                 UUID.fromString(UUID1), DESCRIPTION1);
 447         final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
 448                 UUID.fromString(UUID2), DESCRIPTION2);
 449
 450         pfDao.create(keyInfo0);
 451         pfDao.create(keyInfo1);
 452         pfDao.create(keyInfo2);
 453         pfDao.create(keyInfo3);
 454         pfDao.create(keyInfo4);
 455         pfDao.create(keyInfo5);
 456
 457         assertEquals(3, pfDao.getAllVersions(DummyConceptEntity.class, "AAA0").size());
 458         assertEquals(0, pfDao.getAllVersions(null, "AAA0").size());
 459         assertEquals(0, pfDao.getAllVersions(DummyConceptEntity.class, null).size());
 460     }
 461
 462     private void testgetFilteredOps() {
 463         final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
 464         final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
 465         final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
 466         final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
 467         final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
 468         final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
 469         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 470                 UUID.fromString(UUID0), DESCRIPTION0);
 471         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 472                 UUID.fromString(UUID1), DESCRIPTION1);
 473         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 474                 UUID.fromString(UUID2), DESCRIPTION2);
 475         final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
 476                 UUID.fromString(UUID0), DESCRIPTION0);
 477         final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
 478                 UUID.fromString(UUID1), DESCRIPTION1);
 479         final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
 480                 UUID.fromString(UUID2), DESCRIPTION2);
 481
 482         pfDao.create(keyInfo0);
 483         pfDao.create(keyInfo1);
 484         pfDao.create(keyInfo2);
 485         pfDao.create(keyInfo3);
 486         pfDao.create(keyInfo4);
 487         pfDao.create(keyInfo5);
 488
 489         assertThat(pfDao.getFiltered(DummyConceptEntity.class, null, null)).hasSize(6);
 490         assertThat(pfDao.getFiltered(DummyConceptEntity.class, "AAA0", null)).hasSize(3);
 491         assertThat(pfDao.getFiltered(DummyConceptEntity.class, "BBB0", null)).hasSize(3);
 492         assertThat(pfDao.getFiltered(DummyConceptEntity.class, "BBB0", VERSION003)).hasSize(1);
 493         assertThat(pfDao.getFiltered(DummyConceptEntity.class, null, VERSION003)).hasSize(6);
 494
 495         final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
 496         final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
 497         final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
 498         final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
 499         final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
 500         final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
 501
 502         pfDao.create(tkeyInfo0);
 503         pfDao.create(tkeyInfo1);
 504         pfDao.create(tkeyInfo2);
 505
 506
 507         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 508                         PfFilterParameters.builder().name("AT-KEY0").version(VERSION001).build())).hasSize(1);
 509         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().name("AT-KEY0").build()))
 510                         .hasSize(1);
 511         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().version(VERSION001)
 512                         .startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
 513         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().name("AT-KEY0")
 514                         .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
 515         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 516                         PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
 517         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 518                         PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
 519         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().version(VERSION001)
 520                         .startTime(TIMESTAMP0).endTime(TIMESTAMP2).sortOrder("DESC").recordNum(2).build())).hasSize(2);
 521
 522         Map<String, Object> filterMap = new HashMap<>();
 523         filterMap.put("doubleValue", 200.1);
 524         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 525                         PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);
 526     }
 527
 528     private void testgetFilteredOps3() {
 529         Map<String, Object> filterMap = new HashMap<>();
 530         filterMap.put("localName", "AT-KEY0");
 531
 532         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 533         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 534         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 535         final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
 536         final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
 537         final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
 538         final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
 539         final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
 540         final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
 541
 542         pfDao.create(rkeyInfo0);
 543         pfDao.create(rkeyInfo1);
 544         pfDao.create(rkeyInfo2);
 545
 546
 547         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 548                         PfFilterParameters.builder().name("Owner0").version(VERSION001).build())).hasSize(1);
 549         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 550                         PfFilterParameters.builder().name("Owner0").build())).hasSize(1);
 551         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class, PfFilterParameters.builder()
 552                         .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
 553         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class, PfFilterParameters.builder().name("Owner0")
 554                         .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
 555         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 556                         PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
 557         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 558                         PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
 559         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 560                         PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2)
 561                                         .sortOrder("DESC").recordNum(2).build())).hasSize(2);
 562
 563         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 564                         PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);
 565     }
 566 }