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  * ================================================================================
   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
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.models.dao;
  23
  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;
  29
  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;
  35 import java.util.Map;
  36 import java.util.Properties;
  37 import java.util.Set;
  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;
  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     private static final Long GENERATEDID0 = 10000L;
  69     private static final Long GENERATEDID1 = 10001L;
  70     private static final Long GENERATEDID2 = 10002L;
  71
  72     private PfDao pfDao;
  73
  74     /**
  75      * Closes the DAO.
  76      */
  77     @After
  78     public void tearDown() {
  79         if (pfDao != null) {
  80             pfDao.close();
  81             pfDao = null;
  82         }
  83     }
  84
  85     @Test
  86     public void testEntityTestSanity() throws PfModelException {
  87         final DaoParameters daoParameters = new DaoParameters();
  88
  89         Properties jdbcProperties = new Properties();
  90         // @formatter:off
  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, "");
  95         // @formatter:on
  96
  97         daoParameters.setJdbcProperties(jdbcProperties);
  98
  99         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 100
 101         assertThatThrownBy(() -> pfDao.init(null)).hasMessage("Policy Framework persistence unit parameter not set");
 102
 103         assertThatThrownBy(() -> pfDao.init(daoParameters))
 104                         .hasMessage("Policy Framework persistence unit parameter not set");
 105
 106         daoParameters.setPluginClass("somewhere.over.the.rainbow");
 107         daoParameters.setPersistenceUnit("Dorothy");
 108
 109         assertThatThrownBy(() -> pfDao.init(daoParameters))
 110                         .hasMessage("Creation of Policy Framework persistence unit \"Dorothy\" failed");
 111
 112         assertThatThrownBy(() -> pfDao.create(new PfConceptKey()))
 113                         .hasMessage("Policy Framework DAO has not been initialized");
 114     }
 115
 116     @Test
 117     public void testEntityTestAllOpsJpa() throws PfModelException {
 118
 119         final DaoParameters daoParameters = new DaoParameters();
 120         daoParameters.setPluginClass(DefaultPfDao.class.getName());
 121         daoParameters.setPersistenceUnit("DaoTest");
 122
 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", "");
 128
 129         daoParameters.setJdbcProperties(jdbcProperties);
 130
 131         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 132         pfDao.init(daoParameters);
 133
 134         testAllOps();
 135
 136         testGeneratedId();
 137
 138         testReferenceTimestamp();
 139
 140         testVersionOps();
 141
 142         testgetFilteredOps();
 143
 144         testgetFilteredOps2();
 145
 146         testgetFilteredOps3();
 147     }
 148
 149     @Test
 150     public void testEntityTestBadVals() throws PfModelException {
 151         final DaoParameters daoParameters = new DaoParameters();
 152         daoParameters.setPluginClass(DefaultPfDao.class.getName());
 153         daoParameters.setPersistenceUnit("DaoTest");
 154
 155         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 156         pfDao.init(daoParameters);
 157
 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<>();
 165
 166         pfDao.create(nullKey);
 167         pfDao.createCollection(nullKeyList);
 168         pfDao.createCollection(emptyKeyList);
 169
 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);
 180
 181         pfDao.get(null, nullKey);
 182         pfDao.get(null, nullRefKey);
 183         pfDao.get(null, nullTimeKey);
 184         pfDao.getAll(null);
 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);
 191
 192         assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
 193     }
 194
 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);
 205
 206         pfDao.create(keyInfo0);
 207
 208         final DummyConceptEntity keyInfoBack0 = pfDao.get(DummyConceptEntity.class, aKey0);
 209         assertEquals(keyInfo0, keyInfoBack0);
 210
 211         final DummyConceptEntity keyInfoBackNull = pfDao.get(DummyConceptEntity.class, PfConceptKey.getNullKey());
 212         assertNull(keyInfoBackNull);
 213
 214         final DummyConceptEntity keyInfoBack1 = pfDao.getConcept(DummyConceptEntity.class, aKey0);
 215         assertEquals(keyInfoBack0, keyInfoBack1);
 216
 217         final DummyConceptEntity keyInfoBack2 =
 218                 pfDao.getConcept(DummyConceptEntity.class, new PfConceptKey("A-KEY3", VERSION001));
 219         assertNull(keyInfoBack2);
 220
 221         final Set<DummyConceptEntity> keyInfoSetIn = new TreeSet<>();
 222         keyInfoSetIn.add(keyInfo1);
 223         keyInfoSetIn.add(keyInfo2);
 224
 225         pfDao.createCollection(keyInfoSetIn);
 226
 227         Set<DummyConceptEntity> keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 228
 229         keyInfoSetIn.add(keyInfo0);
 230         assertEquals(keyInfoSetIn, keyInfoSetOut);
 231
 232         pfDao.delete(keyInfo1);
 233         keyInfoSetIn.remove(keyInfo1);
 234         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 235         assertEquals(keyInfoSetIn, keyInfoSetOut);
 236
 237         pfDao.deleteCollection(keyInfoSetIn);
 238         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 239         assertEquals(0, keyInfoSetOut.size());
 240
 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);
 247
 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));
 252
 253         final Set<PfConceptKey> keySetIn = new TreeSet<>();
 254         keySetIn.add(aKey1);
 255         keySetIn.add(aKey2);
 256
 257         final int deletedCount = pfDao.deleteByConceptKey(DummyConceptEntity.class, keySetIn);
 258         assertEquals(2, deletedCount);
 259
 260         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 261         assertEquals(0, keyInfoSetOut.size());
 262
 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);
 269
 270         pfDao.deleteAll(DummyConceptEntity.class);
 271         assertEquals(0, pfDao.size(DummyConceptEntity.class));
 272
 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);
 279
 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));
 296
 297         TreeSet<DummyReferenceEntity> testEntitySetOut =
 298                 new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class));
 299         assertEquals(16, testEntitySetOut.size());
 300
 301         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner0Key));
 302         assertEquals(5, testEntitySetOut.size());
 303
 304         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner1Key));
 305         assertEquals(3, testEntitySetOut.size());
 306
 307         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner2Key));
 308         assertEquals(2, testEntitySetOut.size());
 309
 310         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner3Key));
 311         assertEquals(1, testEntitySetOut.size());
 312
 313         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner4Key));
 314         assertEquals(1, testEntitySetOut.size());
 315
 316         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner5Key));
 317         assertEquals(4, testEntitySetOut.size());
 318
 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));
 324
 325         final Set<PfReferenceKey> rKeySetIn = new TreeSet<>();
 326         rKeySetIn.add(new PfReferenceKey(owner4Key, "EntityB"));
 327         rKeySetIn.add(new PfReferenceKey(owner5Key, "EntityD"));
 328
 329         final int deletedRCount = pfDao.deleteByReferenceKey(DummyReferenceEntity.class, rKeySetIn);
 330         assertEquals(2, deletedRCount);
 331
 332         pfDao.update(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 120.0));
 333
 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);
 340
 341         pfDao.create(tkeyInfo0);
 342
 343         final DummyTimestampEntity tkeyInfoBack0 = pfDao.get(DummyTimestampEntity.class, atKey0);
 344         assertEquals(tkeyInfo0, tkeyInfoBack0);
 345
 346         final DummyTimestampEntity tkeyInfoBackNull =
 347                 pfDao.get(DummyTimestampEntity.class, PfTimestampKey.getNullKey());
 348         assertNull(tkeyInfoBackNull);
 349
 350
 351
 352         final Set<DummyTimestampEntity> tkeyInfoSetIn = new TreeSet<>();
 353         tkeyInfoSetIn.add(tkeyInfo1);
 354         tkeyInfoSetIn.add(tkeyInfo2);
 355
 356         pfDao.createCollection(tkeyInfoSetIn);
 357
 358         Set<DummyTimestampEntity> tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 359
 360         tkeyInfoSetIn.add(tkeyInfo0);
 361         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 362
 363         pfDao.delete(tkeyInfo1);
 364         tkeyInfoSetIn.remove(tkeyInfo1);
 365         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 366         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 367
 368         pfDao.deleteCollection(tkeyInfoSetIn);
 369         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 370         assertEquals(0, tkeyInfoSetOut.size());
 371
 372         tkeyInfoSetIn.add(tkeyInfo2);
 373         pfDao.createCollection(tkeyInfoSetIn);
 374         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 375         assertEquals(keyInfoSetIn, keyInfoSetOut);
 376
 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));
 381
 382         pfDao.deleteAll(DummyTimestampEntity.class);
 383         assertEquals(0, pfDao.size(DummyTimestampEntity.class));
 384     }
 385
 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));
 393
 394         pfDao.create(gkeyInfo0);
 395
 396         final DummyGeneratedIdEntity gkeyInfoBack0 = pfDao.get(DummyGeneratedIdEntity.class, agKey0);
 397         assertEquals(gkeyInfo0, gkeyInfoBack0);
 398
 399         assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey0, TIMESTAMP0).size());
 400
 401         final DummyGeneratedIdEntity gkeyInfoBackNull =
 402                 pfDao.get(DummyGeneratedIdEntity.class, PfGeneratedIdKey.getNullKey());
 403         assertNull(gkeyInfoBackNull);
 404
 405         final Set<DummyGeneratedIdEntity> gkeyInfoSetIn = new TreeSet<>();
 406         gkeyInfoSetIn.add(gkeyInfo1);
 407         gkeyInfoSetIn.add(gkeyInfo2);
 408
 409         pfDao.createCollection(gkeyInfoSetIn);
 410
 411         Set<DummyGeneratedIdEntity> gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 412
 413         gkeyInfoSetIn.add(gkeyInfo0);
 414         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 415
 416         pfDao.delete(gkeyInfo1);
 417         gkeyInfoSetIn.remove(gkeyInfo1);
 418         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 419         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 420
 421         pfDao.deleteCollection(gkeyInfoSetIn);
 422         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 423         assertEquals(0, gkeyInfoSetOut.size());
 424
 425         gkeyInfoSetIn.add(gkeyInfo2);
 426         pfDao.createCollection(gkeyInfoSetIn);
 427         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 428         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 429
 430         pfDao.delete(DummyGeneratedIdEntity.class, agKey2);
 431         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 432         assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
 433
 434         pfDao.deleteAll(DummyGeneratedIdEntity.class);
 435         assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
 436
 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));
 443
 444         pfDao.create(gkeyInfo3);
 445
 446         final DummyGeneratedIdEntity gkeyInfoBack3 = pfDao.get(DummyGeneratedIdEntity.class, agKey3);
 447         assertEquals(gkeyInfo3, gkeyInfoBack3);
 448
 449         assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey3, TIMESTAMP0).size());
 450
 451         assertEquals(1, gkeyInfo3.getKeys().size());
 452
 453         assertEquals(1, gkeyInfo4.compareTo(gkeyInfo3));
 454
 455         assertNull(gkeyInfo4.validate(VERSION002).getResult());
 456
 457
 458         gkeyInfoSetIn.clear();
 459         gkeyInfoSetIn.add(gkeyInfo4);
 460         gkeyInfoSetIn.add(gkeyInfo5);
 461
 462         pfDao.createCollection(gkeyInfoSetIn);
 463
 464         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 465
 466         gkeyInfoSetIn.add(gkeyInfo3);
 467         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 468
 469         pfDao.delete(gkeyInfo4);
 470         gkeyInfoSetIn.remove(gkeyInfo4);
 471         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 472         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 473
 474         pfDao.deleteCollection(gkeyInfoSetIn);
 475         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 476         assertEquals(0, gkeyInfoSetOut.size());
 477
 478         gkeyInfoSetIn.add(gkeyInfo5);
 479         pfDao.createCollection(gkeyInfoSetIn);
 480         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 481         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 482
 483         pfDao.delete(DummyGeneratedIdEntity.class, agKey5);
 484         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 485         assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
 486
 487         pfDao.deleteAll(DummyGeneratedIdEntity.class);
 488         assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
 489     }
 490
 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);
 501
 502         pfDao.create(rkeyInfo0);
 503
 504         final  DummyReferenceTimestampEntity rkeyInfoBack0 = pfDao.get(DummyReferenceTimestampEntity.class, arKey0);
 505         assertEquals(rkeyInfo0, rkeyInfoBack0);
 506
 507
 508         final DummyReferenceTimestampEntity rkeyInfoBackNull =
 509                 pfDao.get(DummyReferenceTimestampEntity.class, PfReferenceTimestampKey.getNullKey());
 510         assertNull(rkeyInfoBackNull);
 511
 512         final Set<DummyReferenceTimestampEntity> rkeyInfoSetIn = new TreeSet<>();
 513         rkeyInfoSetIn.add(rkeyInfo1);
 514         rkeyInfoSetIn.add(rkeyInfo2);
 515
 516         pfDao.createCollection(rkeyInfoSetIn);
 517
 518         Set<DummyReferenceTimestampEntity> rkeyInfoSetOut =
 519                 new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 520
 521         rkeyInfoSetIn.add(rkeyInfo0);
 522         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 523
 524         pfDao.delete(rkeyInfo1);
 525         rkeyInfoSetIn.remove(rkeyInfo1);
 526         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 527         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 528
 529         pfDao.deleteCollection(rkeyInfoSetIn);
 530         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 531         assertEquals(0, rkeyInfoSetOut.size());
 532
 533         rkeyInfoSetIn.add(rkeyInfo2);
 534         pfDao.createCollection(rkeyInfoSetIn);
 535         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 536         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 537
 538         pfDao.deleteAll(DummyReferenceTimestampEntity.class);
 539         assertEquals(0, pfDao.size(DummyReferenceTimestampEntity.class));
 540     }
 541
 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);
 561
 562         pfDao.create(keyInfo0);
 563         pfDao.create(keyInfo1);
 564         pfDao.create(keyInfo2);
 565         pfDao.create(keyInfo3);
 566         pfDao.create(keyInfo4);
 567         pfDao.create(keyInfo5);
 568
 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());
 572     }
 573
 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);
 593
 594         pfDao.create(keyInfo0);
 595         pfDao.create(keyInfo1);
 596         pfDao.create(keyInfo2);
 597         pfDao.create(keyInfo3);
 598         pfDao.create(keyInfo4);
 599         pfDao.create(keyInfo5);
 600
 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());
 606
 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);
 613
 614         pfDao.create(tkeyInfo0);
 615         pfDao.create(tkeyInfo1);
 616         pfDao.create(tkeyInfo2);
 617
 618
 619         assertEquals(1, pfDao
 620                 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
 621         assertEquals(1,
 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)
 625                 .size());
 626         assertEquals(1, pfDao
 627                 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 628                 .size());
 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());
 633         assertEquals(2,
 634                 pfDao.getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
 635                         .size());
 636
 637         Map<String, Object> filterMap = new HashMap<>();
 638         filterMap.put("doubleValue", 200.1);
 639         assertEquals(1,
 640                 pfDao.getFiltered(DummyTimestampEntity.class, null, null, null, null, filterMap, "DESC", 0).size());
 641     }
 642
 643     private void testgetFilteredOps2() {
 644         Map<String, Object> filterMap = new HashMap<>();
 645         filterMap.put("doubleValue", 200.1);
 646
 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);
 653
 654         pfDao.create(gkeyInfo0);
 655         pfDao.create(gkeyInfo1);
 656         pfDao.create(gkeyInfo2);
 657
 658
 659         assertEquals(1, pfDao
 660                 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
 661         assertEquals(1,
 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)
 665                 .size());
 666         assertEquals(1, pfDao
 667                 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001,
 668                         TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 669                 .size());
 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());
 675         assertEquals(2,
 676                 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, VERSION001,
 677                         TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
 678                         .size());
 679
 680         assertEquals(1,
 681                 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, null, null, null, filterMap, "DESC", 0).size());
 682     }
 683
 684     private void testgetFilteredOps3() {
 685         Map<String, Object> filterMap = new HashMap<>();
 686         filterMap.put("localName", "AT-KEY0");
 687
 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);
 697
 698         pfDao.create(rkeyInfo0);
 699         pfDao.create(rkeyInfo1);
 700         pfDao.create(rkeyInfo2);
 701
 702
 703         assertEquals(1, pfDao
 704                 .getFiltered(DummyReferenceTimestampEntity.class,
 705                     "Owner0", VERSION001, null, null, null, "DESC", 0).size());
 706         assertEquals(1,
 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)
 712                 .size());
 713         assertEquals(1, pfDao
 714                 .getFiltered(DummyReferenceTimestampEntity.class,
 715                     "Owner0", VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 716                 .size());
 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());
 723         assertEquals(2,
 724                 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 725                     null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
 726                         .size());
 727
 728         assertEquals(1,
 729                 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 730                     null, null, null, null, filterMap, "DESC", 0).size());
 731     }
 732 }