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.getConcept(null, nullKey);
 187         pfDao.getConcept(PfConceptKey.class, nullKey);
 188         pfDao.getConcept(null, nullRefKey);
 189         pfDao.getConcept(PfReferenceKey.class, nullRefKey);
 190
 191         assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
 192     }
 193
 194     private void testAllOps() {
 195         final PfConceptKey aKey0 = new PfConceptKey("A-KEY0", VERSION001);
 196         final PfConceptKey aKey1 = new PfConceptKey("A-KEY1", VERSION001);
 197         final PfConceptKey aKey2 = new PfConceptKey("A-KEY2", VERSION001);
 198         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 199                 UUID.fromString(UUID0), DESCRIPTION0);
 200         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 201                 UUID.fromString(UUID1), DESCRIPTION1);
 202         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 203                 UUID.fromString(UUID2), DESCRIPTION2);
 204
 205         pfDao.create(keyInfo0);
 206
 207         final DummyConceptEntity keyInfoBack0 = pfDao.get(DummyConceptEntity.class, aKey0);
 208         assertEquals(keyInfo0, keyInfoBack0);
 209
 210         final DummyConceptEntity keyInfoBackNull = pfDao.get(DummyConceptEntity.class, PfConceptKey.getNullKey());
 211         assertNull(keyInfoBackNull);
 212
 213         final DummyConceptEntity keyInfoBack1 = pfDao.getConcept(DummyConceptEntity.class, aKey0);
 214         assertEquals(keyInfoBack0, keyInfoBack1);
 215
 216         final DummyConceptEntity keyInfoBack2 =
 217                 pfDao.getConcept(DummyConceptEntity.class, new PfConceptKey("A-KEY3", VERSION001));
 218         assertNull(keyInfoBack2);
 219
 220         final Set<DummyConceptEntity> keyInfoSetIn = new TreeSet<>();
 221         keyInfoSetIn.add(keyInfo1);
 222         keyInfoSetIn.add(keyInfo2);
 223
 224         pfDao.createCollection(keyInfoSetIn);
 225
 226         Set<DummyConceptEntity> keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 227
 228         keyInfoSetIn.add(keyInfo0);
 229         assertEquals(keyInfoSetIn, keyInfoSetOut);
 230
 231         pfDao.delete(keyInfo1);
 232         keyInfoSetIn.remove(keyInfo1);
 233         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 234         assertEquals(keyInfoSetIn, keyInfoSetOut);
 235
 236         pfDao.deleteCollection(keyInfoSetIn);
 237         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 238         assertEquals(0, keyInfoSetOut.size());
 239
 240         keyInfoSetIn.add(keyInfo0);
 241         keyInfoSetIn.add(keyInfo1);
 242         keyInfoSetIn.add(keyInfo0);
 243         pfDao.createCollection(keyInfoSetIn);
 244         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 245         assertEquals(keyInfoSetIn, keyInfoSetOut);
 246
 247         pfDao.delete(DummyConceptEntity.class, aKey0);
 248         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 249         assertEquals(2, keyInfoSetOut.size());
 250         assertEquals(2, pfDao.size(DummyConceptEntity.class));
 251
 252         final Set<PfConceptKey> keySetIn = new TreeSet<>();
 253         keySetIn.add(aKey1);
 254         keySetIn.add(aKey2);
 255
 256         final int deletedCount = pfDao.deleteByConceptKey(DummyConceptEntity.class, keySetIn);
 257         assertEquals(2, deletedCount);
 258
 259         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 260         assertEquals(0, keyInfoSetOut.size());
 261
 262         keyInfoSetIn.add(keyInfo0);
 263         keyInfoSetIn.add(keyInfo1);
 264         keyInfoSetIn.add(keyInfo0);
 265         pfDao.createCollection(keyInfoSetIn);
 266         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 267         assertEquals(keyInfoSetIn, keyInfoSetOut);
 268
 269         pfDao.deleteAll(DummyConceptEntity.class);
 270         assertEquals(0, pfDao.size(DummyConceptEntity.class));
 271
 272         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 273         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 274         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 275         final PfConceptKey owner3Key = new PfConceptKey("Owner3", VERSION001);
 276         final PfConceptKey owner4Key = new PfConceptKey("Owner4", VERSION001);
 277         final PfConceptKey owner5Key = new PfConceptKey("Owner5", VERSION001);
 278
 279         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, ENTITY0), 100.0));
 280         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity1"), 101.0));
 281         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity2"), 102.0));
 282         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity3"), 103.0));
 283         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity4"), 104.0));
 284         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity5"), 105.0));
 285         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity6"), 106.0));
 286         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity7"), 107.0));
 287         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity8"), 108.0));
 288         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity9"), 109.0));
 289         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner3Key, "EntityA"), 110.0));
 290         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner4Key, "EntityB"), 111.0));
 291         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityC"), 112.0));
 292         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityD"), 113.0));
 293         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityE"), 114.0));
 294         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 115.0));
 295
 296         TreeSet<DummyReferenceEntity> testEntitySetOut =
 297                 new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class));
 298         assertEquals(16, testEntitySetOut.size());
 299
 300         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner0Key));
 301         assertEquals(5, testEntitySetOut.size());
 302
 303         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner1Key));
 304         assertEquals(3, testEntitySetOut.size());
 305
 306         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner2Key));
 307         assertEquals(2, testEntitySetOut.size());
 308
 309         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner3Key));
 310         assertEquals(1, testEntitySetOut.size());
 311
 312         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner4Key));
 313         assertEquals(1, testEntitySetOut.size());
 314
 315         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner5Key));
 316         assertEquals(4, testEntitySetOut.size());
 317
 318         assertNotNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
 319         assertNotNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
 320         assertNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
 321         assertNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
 322         pfDao.delete(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0));
 323
 324         final Set<PfReferenceKey> rKeySetIn = new TreeSet<>();
 325         rKeySetIn.add(new PfReferenceKey(owner4Key, "EntityB"));
 326         rKeySetIn.add(new PfReferenceKey(owner5Key, "EntityD"));
 327
 328         final int deletedRCount = pfDao.deleteByReferenceKey(DummyReferenceEntity.class, rKeySetIn);
 329         assertEquals(2, deletedRCount);
 330
 331         pfDao.update(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 120.0));
 332
 333         final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
 334         final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
 335         final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
 336         final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
 337         final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
 338         final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
 339
 340         pfDao.create(tkeyInfo0);
 341
 342         final DummyTimestampEntity tkeyInfoBack0 = pfDao.get(DummyTimestampEntity.class, atKey0);
 343         assertEquals(tkeyInfo0, tkeyInfoBack0);
 344
 345         final DummyTimestampEntity tkeyInfoBackNull =
 346                 pfDao.get(DummyTimestampEntity.class, PfTimestampKey.getNullKey());
 347         assertNull(tkeyInfoBackNull);
 348
 349
 350
 351         final Set<DummyTimestampEntity> tkeyInfoSetIn = new TreeSet<>();
 352         tkeyInfoSetIn.add(tkeyInfo1);
 353         tkeyInfoSetIn.add(tkeyInfo2);
 354
 355         pfDao.createCollection(tkeyInfoSetIn);
 356
 357         Set<DummyTimestampEntity> tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 358
 359         tkeyInfoSetIn.add(tkeyInfo0);
 360         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 361
 362         pfDao.delete(tkeyInfo1);
 363         tkeyInfoSetIn.remove(tkeyInfo1);
 364         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 365         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 366
 367         pfDao.deleteCollection(tkeyInfoSetIn);
 368         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 369         assertEquals(0, tkeyInfoSetOut.size());
 370
 371         tkeyInfoSetIn.add(tkeyInfo2);
 372         pfDao.createCollection(tkeyInfoSetIn);
 373         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 374         assertEquals(keyInfoSetIn, keyInfoSetOut);
 375
 376         pfDao.delete(DummyTimestampEntity.class, atKey2);
 377         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 378         assertEquals(3, keyInfoSetOut.size());
 379         assertEquals(1, pfDao.size(DummyTimestampEntity.class));
 380
 381         pfDao.deleteAll(DummyTimestampEntity.class);
 382         assertEquals(0, pfDao.size(DummyTimestampEntity.class));
 383     }
 384
 385     private void testGeneratedId() {
 386         final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001, GENERATEDID0);
 387         final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001, GENERATEDID1);
 388         final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001, GENERATEDID2);
 389         final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0));
 390         final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1));
 391         final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2));
 392
 393         pfDao.create(gkeyInfo0);
 394
 395         final DummyGeneratedIdEntity gkeyInfoBack0 = pfDao.get(DummyGeneratedIdEntity.class, agKey0);
 396         assertEquals(gkeyInfo0, gkeyInfoBack0);
 397
 398         assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey0, TIMESTAMP0).size());
 399
 400         final DummyGeneratedIdEntity gkeyInfoBackNull =
 401                 pfDao.get(DummyGeneratedIdEntity.class, PfGeneratedIdKey.getNullKey());
 402         assertNull(gkeyInfoBackNull);
 403
 404         final Set<DummyGeneratedIdEntity> gkeyInfoSetIn = new TreeSet<>();
 405         gkeyInfoSetIn.add(gkeyInfo1);
 406         gkeyInfoSetIn.add(gkeyInfo2);
 407
 408         pfDao.createCollection(gkeyInfoSetIn);
 409
 410         Set<DummyGeneratedIdEntity> gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 411
 412         gkeyInfoSetIn.add(gkeyInfo0);
 413         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 414
 415         pfDao.delete(gkeyInfo1);
 416         gkeyInfoSetIn.remove(gkeyInfo1);
 417         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 418         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 419
 420         pfDao.deleteCollection(gkeyInfoSetIn);
 421         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 422         assertEquals(0, gkeyInfoSetOut.size());
 423
 424         gkeyInfoSetIn.add(gkeyInfo2);
 425         pfDao.createCollection(gkeyInfoSetIn);
 426         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 427         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 428
 429         pfDao.delete(DummyGeneratedIdEntity.class, agKey2);
 430         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 431         assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
 432
 433         pfDao.deleteAll(DummyGeneratedIdEntity.class);
 434         assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
 435
 436         final PfGeneratedIdKey agKey3 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
 437         final PfGeneratedIdKey agKey4 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
 438         final PfGeneratedIdKey agKey5 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
 439         final DummyGeneratedIdEntity gkeyInfo3 = new DummyGeneratedIdEntity(agKey3, Date.from(TIMESTAMP0));
 440         final DummyGeneratedIdEntity gkeyInfo4 = new DummyGeneratedIdEntity(agKey4, Date.from(TIMESTAMP1));
 441         final DummyGeneratedIdEntity gkeyInfo5 = new DummyGeneratedIdEntity(agKey5, Date.from(TIMESTAMP2));
 442
 443         pfDao.create(gkeyInfo3);
 444
 445         final DummyGeneratedIdEntity gkeyInfoBack3 = pfDao.get(DummyGeneratedIdEntity.class, agKey3);
 446         assertEquals(gkeyInfo3, gkeyInfoBack3);
 447
 448         assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey3, TIMESTAMP0).size());
 449
 450         assertEquals(1, gkeyInfo3.getKeys().size());
 451
 452         assertEquals(1, gkeyInfo4.compareTo(gkeyInfo3));
 453
 454         assertNull(gkeyInfo4.validate(VERSION002).getResult());
 455
 456
 457         gkeyInfoSetIn.clear();
 458         gkeyInfoSetIn.add(gkeyInfo4);
 459         gkeyInfoSetIn.add(gkeyInfo5);
 460
 461         pfDao.createCollection(gkeyInfoSetIn);
 462
 463         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 464
 465         gkeyInfoSetIn.add(gkeyInfo3);
 466         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 467
 468         pfDao.delete(gkeyInfo4);
 469         gkeyInfoSetIn.remove(gkeyInfo4);
 470         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 471         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 472
 473         pfDao.deleteCollection(gkeyInfoSetIn);
 474         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 475         assertEquals(0, gkeyInfoSetOut.size());
 476
 477         gkeyInfoSetIn.add(gkeyInfo5);
 478         pfDao.createCollection(gkeyInfoSetIn);
 479         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 480         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 481
 482         pfDao.delete(DummyGeneratedIdEntity.class, agKey5);
 483         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 484         assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
 485
 486         pfDao.deleteAll(DummyGeneratedIdEntity.class);
 487         assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
 488     }
 489
 490     private void testReferenceTimestamp() {
 491         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 492         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 493         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 494         final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
 495         final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
 496         final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
 497         final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
 498         final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
 499         final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
 500
 501         pfDao.create(rkeyInfo0);
 502
 503         final  DummyReferenceTimestampEntity rkeyInfoBack0 = pfDao.get(DummyReferenceTimestampEntity.class, arKey0);
 504         assertEquals(rkeyInfo0, rkeyInfoBack0);
 505
 506
 507         final DummyReferenceTimestampEntity rkeyInfoBackNull =
 508                 pfDao.get(DummyReferenceTimestampEntity.class, PfReferenceTimestampKey.getNullKey());
 509         assertNull(rkeyInfoBackNull);
 510
 511         final Set<DummyReferenceTimestampEntity> rkeyInfoSetIn = new TreeSet<>();
 512         rkeyInfoSetIn.add(rkeyInfo1);
 513         rkeyInfoSetIn.add(rkeyInfo2);
 514
 515         pfDao.createCollection(rkeyInfoSetIn);
 516
 517         Set<DummyReferenceTimestampEntity> rkeyInfoSetOut =
 518                 new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 519
 520         rkeyInfoSetIn.add(rkeyInfo0);
 521         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 522
 523         pfDao.delete(rkeyInfo1);
 524         rkeyInfoSetIn.remove(rkeyInfo1);
 525         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 526         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 527
 528         pfDao.deleteCollection(rkeyInfoSetIn);
 529         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 530         assertEquals(0, rkeyInfoSetOut.size());
 531
 532         rkeyInfoSetIn.add(rkeyInfo2);
 533         pfDao.createCollection(rkeyInfoSetIn);
 534         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 535         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 536
 537         pfDao.deleteAll(DummyReferenceTimestampEntity.class);
 538         assertEquals(0, pfDao.size(DummyReferenceTimestampEntity.class));
 539     }
 540
 541     private void testVersionOps() {
 542         final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
 543         final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
 544         final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
 545         final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
 546         final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
 547         final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
 548         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 549                 UUID.fromString(UUID0), DESCRIPTION0);
 550         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 551                 UUID.fromString(UUID1), DESCRIPTION1);
 552         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 553                 UUID.fromString(UUID2), DESCRIPTION2);
 554         final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
 555                 UUID.fromString(UUID0), DESCRIPTION0);
 556         final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
 557                 UUID.fromString(UUID1), DESCRIPTION1);
 558         final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
 559                 UUID.fromString(UUID2), DESCRIPTION2);
 560
 561         pfDao.create(keyInfo0);
 562         pfDao.create(keyInfo1);
 563         pfDao.create(keyInfo2);
 564         pfDao.create(keyInfo3);
 565         pfDao.create(keyInfo4);
 566         pfDao.create(keyInfo5);
 567
 568         assertEquals(3, pfDao.getAllVersions(DummyConceptEntity.class, "AAA0").size());
 569         assertEquals(0, pfDao.getAllVersions(null, "AAA0").size());
 570         assertEquals(0, pfDao.getAllVersions(DummyConceptEntity.class, null).size());
 571     }
 572
 573     private void testgetFilteredOps() {
 574         final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
 575         final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
 576         final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
 577         final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
 578         final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
 579         final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
 580         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 581                 UUID.fromString(UUID0), DESCRIPTION0);
 582         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 583                 UUID.fromString(UUID1), DESCRIPTION1);
 584         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 585                 UUID.fromString(UUID2), DESCRIPTION2);
 586         final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
 587                 UUID.fromString(UUID0), DESCRIPTION0);
 588         final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
 589                 UUID.fromString(UUID1), DESCRIPTION1);
 590         final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
 591                 UUID.fromString(UUID2), DESCRIPTION2);
 592
 593         pfDao.create(keyInfo0);
 594         pfDao.create(keyInfo1);
 595         pfDao.create(keyInfo2);
 596         pfDao.create(keyInfo3);
 597         pfDao.create(keyInfo4);
 598         pfDao.create(keyInfo5);
 599
 600         assertEquals(6, pfDao.getFiltered(DummyConceptEntity.class, null, null).size());
 601         assertEquals(3, pfDao.getFiltered(DummyConceptEntity.class, "AAA0", null).size());
 602         assertEquals(3, pfDao.getFiltered(DummyConceptEntity.class, "BBB0", null).size());
 603         assertEquals(1, pfDao.getFiltered(DummyConceptEntity.class, "BBB0", VERSION003).size());
 604         assertEquals(6, pfDao.getFiltered(DummyConceptEntity.class, null, VERSION003).size());
 605
 606         final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
 607         final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
 608         final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
 609         final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
 610         final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
 611         final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
 612
 613         pfDao.create(tkeyInfo0);
 614         pfDao.create(tkeyInfo1);
 615         pfDao.create(tkeyInfo2);
 616
 617
 618         assertEquals(1, pfDao
 619                 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
 620         assertEquals(1,
 621                 pfDao.getFiltered(DummyTimestampEntity.class, "AT-KEY0", null, null, null, null, "DESC", 0).size());
 622         assertEquals(3, pfDao
 623                 .getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 624                 .size());
 625         assertEquals(1, pfDao
 626                 .getFiltered(DummyTimestampEntity.class, "AT-KEY0", VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 627                 .size());
 628         assertEquals(3, pfDao
 629                 .getFiltered(DummyTimestampEntity.class, null, VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
 630         assertEquals(3, pfDao
 631                 .getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, null, null, "DESC", 0).size());
 632         assertEquals(2,
 633                 pfDao.getFiltered(DummyTimestampEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
 634                         .size());
 635
 636         Map<String, Object> filterMap = new HashMap<>();
 637         filterMap.put("doubleValue", 200.1);
 638         assertEquals(1,
 639                 pfDao.getFiltered(DummyTimestampEntity.class, null, null, null, null, filterMap, "DESC", 0).size());
 640     }
 641
 642     private void testgetFilteredOps2() {
 643         Map<String, Object> filterMap = new HashMap<>();
 644         filterMap.put("doubleValue", 200.1);
 645
 646         final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
 647         final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
 648         final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
 649         final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0), 200.0);
 650         final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1), 200.1);
 651         final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2), 200.2);
 652
 653         pfDao.create(gkeyInfo0);
 654         pfDao.create(gkeyInfo1);
 655         pfDao.create(gkeyInfo2);
 656
 657
 658         assertEquals(1, pfDao
 659                 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001, null, null, null, "DESC", 0).size());
 660         assertEquals(1,
 661                 pfDao.getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", null, null, null, null, "DESC", 0).size());
 662         assertEquals(3, pfDao
 663                 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 664                 .size());
 665         assertEquals(1, pfDao
 666                 .getFiltered(DummyGeneratedIdEntity.class, "AT-KEY0", VERSION001,
 667                         TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 668                 .size());
 669         assertEquals(3, pfDao
 670                 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
 671         assertEquals(3, pfDao
 672                 .getFiltered(DummyGeneratedIdEntity.class, null, VERSION001,
 673                         TIMESTAMP0, null, null, "DESC", 0).size());
 674         assertEquals(2,
 675                 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, VERSION001,
 676                         TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
 677                         .size());
 678
 679         assertEquals(1,
 680                 pfDao.getFiltered(DummyGeneratedIdEntity.class, null, null, null, null, filterMap, "DESC", 0).size());
 681     }
 682
 683     private void testgetFilteredOps3() {
 684         Map<String, Object> filterMap = new HashMap<>();
 685         filterMap.put("localName", "AT-KEY0");
 686
 687         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 688         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 689         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 690         final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
 691         final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
 692         final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
 693         final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
 694         final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
 695         final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
 696
 697         pfDao.create(rkeyInfo0);
 698         pfDao.create(rkeyInfo1);
 699         pfDao.create(rkeyInfo2);
 700
 701
 702         assertEquals(1, pfDao
 703                 .getFiltered(DummyReferenceTimestampEntity.class,
 704                     "Owner0", VERSION001, null, null, null, "DESC", 0).size());
 705         assertEquals(1,
 706                 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 707                     "Owner0", null, null, null, null, "DESC", 0).size());
 708         assertEquals(3, pfDao
 709                 .getFiltered(DummyReferenceTimestampEntity.class,
 710                     null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 711                 .size());
 712         assertEquals(1, pfDao
 713                 .getFiltered(DummyReferenceTimestampEntity.class,
 714                     "Owner0", VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 0)
 715                 .size());
 716         assertEquals(3, pfDao
 717                 .getFiltered(DummyReferenceTimestampEntity.class, null,
 718                     VERSION001, null, TIMESTAMP2, null, "DESC", 0).size());
 719         assertEquals(3, pfDao
 720                 .getFiltered(DummyReferenceTimestampEntity.class, null,
 721                     VERSION001, TIMESTAMP0, null, null, "DESC", 0).size());
 722         assertEquals(2,
 723                 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 724                     null, VERSION001, TIMESTAMP0, TIMESTAMP2, null, "DESC", 2)
 725                         .size());
 726
 727         assertEquals(1,
 728                 pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 729                     null, null, null, null, filterMap, "DESC", 0).size());
 730     }
 731 }