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.assertThat;
  25 import static org.assertj.core.api.Assertions.assertThatCode;
  26 import static org.assertj.core.api.Assertions.assertThatThrownBy;
  27 import static org.junit.Assert.assertEquals;
  28 import static org.junit.Assert.assertNotNull;
  29 import static org.junit.Assert.assertNull;
  30
  31 import java.time.Instant;
  32 import java.util.ArrayList;
  33 import java.util.Date;
  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.PfGeneratedIdKey;
  46 import org.onap.policy.models.base.PfModelException;
  47 import org.onap.policy.models.base.PfReferenceKey;
  48 import org.onap.policy.models.base.PfReferenceTimestampKey;
  49 import org.onap.policy.models.base.PfTimestampKey;
  50 import org.onap.policy.models.dao.impl.DefaultPfDao;
  51
  52 /**
  53  * JUnit test class.
  54  */
  55 public class EntityTest {
  56     private static final String DESCRIPTION2 = "key description 2";
  57     private static final String DESCRIPTION1 = "key description 1";
  58     private static final String DESCRIPTION0 = "key description 0";
  59     private static final String ENTITY0 = "Entity0";
  60     private static final String UUID2 = "00000000-0000-0000-0000-000000000002";
  61     private static final String UUID1 = "00000000-0000-0000-0000-000000000001";
  62     private static final String UUID0 = "00000000-0000-0000-0000-000000000000";
  63     private static final String VERSION003 = "0.0.3";
  64     private static final String VERSION002 = "0.0.2";
  65     private static final String VERSION001 = "0.0.1";
  66     private static final Instant TIMESTAMP0 = Instant.ofEpochSecond(1613494293);
  67     private static final Instant TIMESTAMP1 = Instant.ofEpochSecond(1613494293).plusSeconds(55);
  68     private static final Instant TIMESTAMP2 = Instant.ofEpochSecond(1613494293).plusSeconds(90);
  69     private static final Long GENERATEDID0 = 10000L;
  70     private static final Long GENERATEDID1 = 10001L;
  71     private static final Long GENERATEDID2 = 10002L;
  72
  73     private PfDao pfDao;
  74
  75     /**
  76      * Closes the DAO.
  77      */
  78     @After
  79     public void tearDown() {
  80         if (pfDao != null) {
  81             pfDao.close();
  82             pfDao = null;
  83         }
  84     }
  85
  86     @Test
  87     public void testEntityTestSanity() throws PfModelException {
  88         final DaoParameters daoParameters = new DaoParameters();
  89
  90         Properties jdbcProperties = new Properties();
  91         // @formatter:off
  92         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_DRIVER,   "org.h2.Driver");
  93         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_URL,      "jdbc:h2:mem:EntityTest");
  94         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_USER,     "sa");
  95         jdbcProperties.setProperty(PersistenceUnitProperties.JDBC_PASSWORD, "");
  96         // @formatter:on
  97
  98         daoParameters.setJdbcProperties(jdbcProperties);
  99
 100         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 101
 102         assertThatThrownBy(() -> pfDao.init(null)).hasMessage("Policy Framework persistence unit parameter not set");
 103
 104         assertThatThrownBy(() -> pfDao.init(daoParameters))
 105                         .hasMessage("Policy Framework persistence unit parameter not set");
 106
 107         daoParameters.setPluginClass("somewhere.over.the.rainbow");
 108         daoParameters.setPersistenceUnit("Dorothy");
 109
 110         assertThatThrownBy(() -> pfDao.init(daoParameters))
 111                         .hasMessage("Creation of Policy Framework persistence unit \"Dorothy\" failed");
 112
 113         assertThatThrownBy(() -> pfDao.create(new PfConceptKey()))
 114                         .hasMessage("Policy Framework DAO has not been initialized");
 115     }
 116
 117     @Test
 118     public void testEntityTestAllOpsJpa() throws PfModelException {
 119
 120         final DaoParameters daoParameters = new DaoParameters();
 121         daoParameters.setPluginClass(DefaultPfDao.class.getName());
 122         daoParameters.setPersistenceUnit("DaoTest");
 123
 124         Properties jdbcProperties = new Properties();
 125         jdbcProperties.setProperty("javax.persistence.jdbc.driver", "org.h2.Driver");
 126         jdbcProperties.setProperty("javax.persistence.jdbc.url", "jdbc:h2:mem:EntityTest");
 127         jdbcProperties.setProperty("javax.persistence.jdbc.user", "sa");
 128         jdbcProperties.setProperty("javax.persistence.jdbc.password", "");
 129
 130         daoParameters.setJdbcProperties(jdbcProperties);
 131
 132         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 133         pfDao.init(daoParameters);
 134
 135         testAllOps();
 136
 137         testGeneratedId();
 138
 139         testReferenceTimestamp();
 140
 141         testVersionOps();
 142
 143         testgetFilteredOps();
 144
 145         testgetFilteredOps2();
 146
 147         testgetFilteredOps3();
 148     }
 149
 150     @Test
 151     public void testEntityTestBadVals() throws PfModelException {
 152         final DaoParameters daoParameters = new DaoParameters();
 153         daoParameters.setPluginClass(DefaultPfDao.class.getName());
 154         daoParameters.setPersistenceUnit("DaoTest");
 155
 156         pfDao = new PfDaoFactory().createPfDao(daoParameters);
 157         pfDao.init(daoParameters);
 158
 159         final PfConceptKey nullKey = null;
 160         final PfReferenceKey nullRefKey = null;
 161         final PfTimestampKey nullTimeKey = null;
 162         final List<PfConceptKey> nullKeyList = null;
 163         final List<PfConceptKey> emptyKeyList = new ArrayList<>();
 164         final List<PfReferenceKey> nullRKeyList = null;
 165         final List<PfReferenceKey> emptyRKeyList = new ArrayList<>();
 166
 167         pfDao.create(nullKey);
 168         pfDao.createCollection(nullKeyList);
 169         pfDao.createCollection(emptyKeyList);
 170
 171         pfDao.delete(nullKey);
 172         pfDao.deleteCollection(nullKeyList);
 173         pfDao.deleteCollection(emptyKeyList);
 174         pfDao.delete(PfConceptKey.class, nullKey);
 175         pfDao.delete(PfReferenceKey.class, nullRefKey);
 176         pfDao.delete(PfTimestampKey.class, nullTimeKey);
 177         pfDao.deleteByConceptKey(PfConceptKey.class, nullKeyList);
 178         pfDao.deleteByConceptKey(PfConceptKey.class, emptyKeyList);
 179         pfDao.deleteByReferenceKey(PfReferenceKey.class, nullRKeyList);
 180         pfDao.deleteByReferenceKey(PfReferenceKey.class, emptyRKeyList);
 181
 182         pfDao.get(null, nullKey);
 183         pfDao.get(null, nullRefKey);
 184         pfDao.get(null, nullTimeKey);
 185         pfDao.getAll(null);
 186         pfDao.getAll(null, nullKey);
 187         pfDao.getAll(null, null, null);
 188         pfDao.getConcept(null, nullKey);
 189         pfDao.getConcept(PfConceptKey.class, nullKey);
 190         pfDao.getConcept(null, nullRefKey);
 191         pfDao.getConcept(PfReferenceKey.class, nullRefKey);
 192
 193         assertThatCode(() -> pfDao.size(null)).doesNotThrowAnyException();
 194     }
 195
 196     private void testAllOps() {
 197         final PfConceptKey aKey0 = new PfConceptKey("A-KEY0", VERSION001);
 198         final PfConceptKey aKey1 = new PfConceptKey("A-KEY1", VERSION001);
 199         final PfConceptKey aKey2 = new PfConceptKey("A-KEY2", VERSION001);
 200         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 201                 UUID.fromString(UUID0), DESCRIPTION0);
 202         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 203                 UUID.fromString(UUID1), DESCRIPTION1);
 204         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 205                 UUID.fromString(UUID2), DESCRIPTION2);
 206
 207         pfDao.create(keyInfo0);
 208
 209         final DummyConceptEntity keyInfoBack0 = pfDao.get(DummyConceptEntity.class, aKey0);
 210         assertEquals(keyInfo0, keyInfoBack0);
 211
 212         final DummyConceptEntity keyInfoBackNull = pfDao.get(DummyConceptEntity.class, PfConceptKey.getNullKey());
 213         assertNull(keyInfoBackNull);
 214
 215         final DummyConceptEntity keyInfoBack1 = pfDao.getConcept(DummyConceptEntity.class, aKey0);
 216         assertEquals(keyInfoBack0, keyInfoBack1);
 217
 218         final DummyConceptEntity keyInfoBack2 =
 219                 pfDao.getConcept(DummyConceptEntity.class, new PfConceptKey("A-KEY3", VERSION001));
 220         assertNull(keyInfoBack2);
 221
 222         final Set<DummyConceptEntity> keyInfoSetIn = new TreeSet<>();
 223         keyInfoSetIn.add(keyInfo1);
 224         keyInfoSetIn.add(keyInfo2);
 225
 226         pfDao.createCollection(keyInfoSetIn);
 227
 228         Set<DummyConceptEntity> keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 229
 230         keyInfoSetIn.add(keyInfo0);
 231         assertEquals(keyInfoSetIn, keyInfoSetOut);
 232
 233         pfDao.delete(keyInfo1);
 234         keyInfoSetIn.remove(keyInfo1);
 235         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 236         assertEquals(keyInfoSetIn, keyInfoSetOut);
 237
 238         pfDao.deleteCollection(keyInfoSetIn);
 239         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 240         assertEquals(0, keyInfoSetOut.size());
 241
 242         keyInfoSetIn.add(keyInfo0);
 243         keyInfoSetIn.add(keyInfo1);
 244         keyInfoSetIn.add(keyInfo0);
 245         pfDao.createCollection(keyInfoSetIn);
 246         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 247         assertEquals(keyInfoSetIn, keyInfoSetOut);
 248
 249         pfDao.delete(DummyConceptEntity.class, aKey0);
 250         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 251         assertEquals(2, keyInfoSetOut.size());
 252         assertEquals(2, pfDao.size(DummyConceptEntity.class));
 253
 254         final Set<PfConceptKey> keySetIn = new TreeSet<>();
 255         keySetIn.add(aKey1);
 256         keySetIn.add(aKey2);
 257
 258         final int deletedCount = pfDao.deleteByConceptKey(DummyConceptEntity.class, keySetIn);
 259         assertEquals(2, deletedCount);
 260
 261         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 262         assertEquals(0, keyInfoSetOut.size());
 263
 264         keyInfoSetIn.add(keyInfo0);
 265         keyInfoSetIn.add(keyInfo1);
 266         keyInfoSetIn.add(keyInfo0);
 267         pfDao.createCollection(keyInfoSetIn);
 268         keyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyConceptEntity.class));
 269         assertEquals(keyInfoSetIn, keyInfoSetOut);
 270
 271         pfDao.deleteAll(DummyConceptEntity.class);
 272         assertEquals(0, pfDao.size(DummyConceptEntity.class));
 273
 274         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 275         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 276         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 277         final PfConceptKey owner3Key = new PfConceptKey("Owner3", VERSION001);
 278         final PfConceptKey owner4Key = new PfConceptKey("Owner4", VERSION001);
 279         final PfConceptKey owner5Key = new PfConceptKey("Owner5", VERSION001);
 280
 281         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, ENTITY0), 100.0));
 282         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity1"), 101.0));
 283         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity2"), 102.0));
 284         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity3"), 103.0));
 285         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner0Key, "Entity4"), 104.0));
 286         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity5"), 105.0));
 287         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity6"), 106.0));
 288         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner1Key, "Entity7"), 107.0));
 289         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity8"), 108.0));
 290         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner2Key, "Entity9"), 109.0));
 291         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner3Key, "EntityA"), 110.0));
 292         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner4Key, "EntityB"), 111.0));
 293         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityC"), 112.0));
 294         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityD"), 113.0));
 295         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityE"), 114.0));
 296         pfDao.create(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 115.0));
 297
 298         TreeSet<DummyReferenceEntity> testEntitySetOut =
 299                 new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class));
 300         assertEquals(16, testEntitySetOut.size());
 301
 302         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner0Key));
 303         assertEquals(5, testEntitySetOut.size());
 304
 305         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner1Key));
 306         assertEquals(3, testEntitySetOut.size());
 307
 308         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner2Key));
 309         assertEquals(2, testEntitySetOut.size());
 310
 311         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner3Key));
 312         assertEquals(1, testEntitySetOut.size());
 313
 314         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner4Key));
 315         assertEquals(1, testEntitySetOut.size());
 316
 317         testEntitySetOut = new TreeSet<>(pfDao.getAll(DummyReferenceEntity.class, owner5Key));
 318         assertEquals(4, testEntitySetOut.size());
 319
 320         assertNotNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
 321         assertNotNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0)));
 322         assertNull(pfDao.get(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
 323         assertNull(pfDao.getConcept(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, "Entity1000")));
 324         pfDao.delete(DummyReferenceEntity.class, new PfReferenceKey(owner0Key, ENTITY0));
 325
 326         final Set<PfReferenceKey> rKeySetIn = new TreeSet<>();
 327         rKeySetIn.add(new PfReferenceKey(owner4Key, "EntityB"));
 328         rKeySetIn.add(new PfReferenceKey(owner5Key, "EntityD"));
 329
 330         final int deletedRCount = pfDao.deleteByReferenceKey(DummyReferenceEntity.class, rKeySetIn);
 331         assertEquals(2, deletedRCount);
 332
 333         pfDao.update(new DummyReferenceEntity(new PfReferenceKey(owner5Key, "EntityF"), 120.0));
 334
 335         final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
 336         final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
 337         final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
 338         final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
 339         final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
 340         final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
 341
 342         pfDao.create(tkeyInfo0);
 343
 344         final DummyTimestampEntity tkeyInfoBack0 = pfDao.get(DummyTimestampEntity.class, atKey0);
 345         assertEquals(tkeyInfo0, tkeyInfoBack0);
 346
 347         final DummyTimestampEntity tkeyInfoBackNull =
 348                 pfDao.get(DummyTimestampEntity.class, PfTimestampKey.getNullKey());
 349         assertNull(tkeyInfoBackNull);
 350
 351
 352
 353         final Set<DummyTimestampEntity> tkeyInfoSetIn = new TreeSet<>();
 354         tkeyInfoSetIn.add(tkeyInfo1);
 355         tkeyInfoSetIn.add(tkeyInfo2);
 356
 357         pfDao.createCollection(tkeyInfoSetIn);
 358
 359         Set<DummyTimestampEntity> tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 360
 361         tkeyInfoSetIn.add(tkeyInfo0);
 362         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 363
 364         pfDao.delete(tkeyInfo1);
 365         tkeyInfoSetIn.remove(tkeyInfo1);
 366         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 367         assertEquals(tkeyInfoSetIn, tkeyInfoSetOut);
 368
 369         pfDao.deleteCollection(tkeyInfoSetIn);
 370         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 371         assertEquals(0, tkeyInfoSetOut.size());
 372
 373         tkeyInfoSetIn.add(tkeyInfo2);
 374         pfDao.createCollection(tkeyInfoSetIn);
 375         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 376         assertEquals(keyInfoSetIn, keyInfoSetOut);
 377
 378         pfDao.delete(DummyTimestampEntity.class, atKey2);
 379         tkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyTimestampEntity.class));
 380         assertEquals(3, keyInfoSetOut.size());
 381         assertEquals(1, pfDao.size(DummyTimestampEntity.class));
 382
 383         pfDao.deleteAll(DummyTimestampEntity.class);
 384         assertEquals(0, pfDao.size(DummyTimestampEntity.class));
 385     }
 386
 387     private void testGeneratedId() {
 388         final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001, GENERATEDID0);
 389         final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001, GENERATEDID1);
 390         final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001, GENERATEDID2);
 391         final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0));
 392         final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1));
 393         final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2));
 394
 395         pfDao.create(gkeyInfo0);
 396
 397         final DummyGeneratedIdEntity gkeyInfoBack0 = pfDao.get(DummyGeneratedIdEntity.class, agKey0);
 398         assertEquals(gkeyInfo0, gkeyInfoBack0);
 399
 400         assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey0, TIMESTAMP0).size());
 401
 402         final DummyGeneratedIdEntity gkeyInfoBackNull =
 403                 pfDao.get(DummyGeneratedIdEntity.class, PfGeneratedIdKey.getNullKey());
 404         assertNull(gkeyInfoBackNull);
 405
 406         final Set<DummyGeneratedIdEntity> gkeyInfoSetIn = new TreeSet<>();
 407         gkeyInfoSetIn.add(gkeyInfo1);
 408         gkeyInfoSetIn.add(gkeyInfo2);
 409
 410         pfDao.createCollection(gkeyInfoSetIn);
 411
 412         Set<DummyGeneratedIdEntity> gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 413
 414         gkeyInfoSetIn.add(gkeyInfo0);
 415         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 416
 417         pfDao.delete(gkeyInfo1);
 418         gkeyInfoSetIn.remove(gkeyInfo1);
 419         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 420         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 421
 422         pfDao.deleteCollection(gkeyInfoSetIn);
 423         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 424         assertEquals(0, gkeyInfoSetOut.size());
 425
 426         gkeyInfoSetIn.add(gkeyInfo2);
 427         pfDao.createCollection(gkeyInfoSetIn);
 428         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 429         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 430
 431         pfDao.delete(DummyGeneratedIdEntity.class, agKey2);
 432         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 433         assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
 434
 435         pfDao.deleteAll(DummyGeneratedIdEntity.class);
 436         assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
 437
 438         final PfGeneratedIdKey agKey3 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
 439         final PfGeneratedIdKey agKey4 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
 440         final PfGeneratedIdKey agKey5 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
 441         final DummyGeneratedIdEntity gkeyInfo3 = new DummyGeneratedIdEntity(agKey3, Date.from(TIMESTAMP0));
 442         final DummyGeneratedIdEntity gkeyInfo4 = new DummyGeneratedIdEntity(agKey4, Date.from(TIMESTAMP1));
 443         final DummyGeneratedIdEntity gkeyInfo5 = new DummyGeneratedIdEntity(agKey5, Date.from(TIMESTAMP2));
 444
 445         pfDao.create(gkeyInfo3);
 446
 447         final DummyGeneratedIdEntity gkeyInfoBack3 = pfDao.get(DummyGeneratedIdEntity.class, agKey3);
 448         assertEquals(gkeyInfo3, gkeyInfoBack3);
 449
 450         assertEquals(1, pfDao.getByTimestamp(DummyGeneratedIdEntity.class, agKey3, TIMESTAMP0).size());
 451
 452         assertEquals(1, gkeyInfo3.getKeys().size());
 453
 454         assertEquals(1, gkeyInfo4.compareTo(gkeyInfo3));
 455
 456         assertNull(gkeyInfo4.validate(VERSION002).getResult());
 457
 458
 459         gkeyInfoSetIn.clear();
 460         gkeyInfoSetIn.add(gkeyInfo4);
 461         gkeyInfoSetIn.add(gkeyInfo5);
 462
 463         pfDao.createCollection(gkeyInfoSetIn);
 464
 465         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 466
 467         gkeyInfoSetIn.add(gkeyInfo3);
 468         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 469
 470         pfDao.delete(gkeyInfo4);
 471         gkeyInfoSetIn.remove(gkeyInfo4);
 472         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 473         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 474
 475         pfDao.deleteCollection(gkeyInfoSetIn);
 476         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 477         assertEquals(0, gkeyInfoSetOut.size());
 478
 479         gkeyInfoSetIn.add(gkeyInfo5);
 480         pfDao.createCollection(gkeyInfoSetIn);
 481         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 482         assertEquals(gkeyInfoSetIn, gkeyInfoSetOut);
 483
 484         pfDao.delete(DummyGeneratedIdEntity.class, agKey5);
 485         gkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyGeneratedIdEntity.class));
 486         assertEquals(gkeyInfoSetOut.size(), pfDao.size(DummyGeneratedIdEntity.class));
 487
 488         pfDao.deleteAll(DummyGeneratedIdEntity.class);
 489         assertEquals(0, pfDao.size(DummyGeneratedIdEntity.class));
 490     }
 491
 492     private void testReferenceTimestamp() {
 493         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 494         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 495         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 496         final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
 497         final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
 498         final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
 499         final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
 500         final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
 501         final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
 502
 503         pfDao.create(rkeyInfo0);
 504
 505         final  DummyReferenceTimestampEntity rkeyInfoBack0 = pfDao.get(DummyReferenceTimestampEntity.class, arKey0);
 506         assertEquals(rkeyInfo0, rkeyInfoBack0);
 507
 508
 509         final DummyReferenceTimestampEntity rkeyInfoBackNull =
 510                 pfDao.get(DummyReferenceTimestampEntity.class, PfReferenceTimestampKey.getNullKey());
 511         assertNull(rkeyInfoBackNull);
 512
 513         final Set<DummyReferenceTimestampEntity> rkeyInfoSetIn = new TreeSet<>();
 514         rkeyInfoSetIn.add(rkeyInfo1);
 515         rkeyInfoSetIn.add(rkeyInfo2);
 516
 517         pfDao.createCollection(rkeyInfoSetIn);
 518
 519         Set<DummyReferenceTimestampEntity> rkeyInfoSetOut =
 520                 new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 521
 522         rkeyInfoSetIn.add(rkeyInfo0);
 523         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 524
 525         pfDao.delete(rkeyInfo1);
 526         rkeyInfoSetIn.remove(rkeyInfo1);
 527         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 528         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 529
 530         pfDao.deleteCollection(rkeyInfoSetIn);
 531         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 532         assertEquals(0, rkeyInfoSetOut.size());
 533
 534         rkeyInfoSetIn.add(rkeyInfo2);
 535         pfDao.createCollection(rkeyInfoSetIn);
 536         rkeyInfoSetOut = new TreeSet<>(pfDao.getAll(DummyReferenceTimestampEntity.class));
 537         assertEquals(rkeyInfoSetIn, rkeyInfoSetOut);
 538
 539         pfDao.deleteAll(DummyReferenceTimestampEntity.class);
 540         assertEquals(0, pfDao.size(DummyReferenceTimestampEntity.class));
 541     }
 542
 543     private void testVersionOps() {
 544         final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
 545         final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
 546         final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
 547         final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
 548         final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
 549         final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
 550         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 551                 UUID.fromString(UUID0), DESCRIPTION0);
 552         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 553                 UUID.fromString(UUID1), DESCRIPTION1);
 554         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 555                 UUID.fromString(UUID2), DESCRIPTION2);
 556         final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
 557                 UUID.fromString(UUID0), DESCRIPTION0);
 558         final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
 559                 UUID.fromString(UUID1), DESCRIPTION1);
 560         final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
 561                 UUID.fromString(UUID2), DESCRIPTION2);
 562
 563         pfDao.create(keyInfo0);
 564         pfDao.create(keyInfo1);
 565         pfDao.create(keyInfo2);
 566         pfDao.create(keyInfo3);
 567         pfDao.create(keyInfo4);
 568         pfDao.create(keyInfo5);
 569
 570         assertEquals(3, pfDao.getAllVersions(DummyConceptEntity.class, "AAA0").size());
 571         assertEquals(0, pfDao.getAllVersions(null, "AAA0").size());
 572         assertEquals(0, pfDao.getAllVersions(DummyConceptEntity.class, null).size());
 573     }
 574
 575     private void testgetFilteredOps() {
 576         final PfConceptKey aKey0 = new PfConceptKey("AAA0", VERSION001);
 577         final PfConceptKey aKey1 = new PfConceptKey("AAA0", VERSION002);
 578         final PfConceptKey aKey2 = new PfConceptKey("AAA0", VERSION003);
 579         final PfConceptKey bKey0 = new PfConceptKey("BBB0", VERSION001);
 580         final PfConceptKey bKey1 = new PfConceptKey("BBB0", VERSION002);
 581         final PfConceptKey bKey2 = new PfConceptKey("BBB0", VERSION003);
 582         final DummyConceptEntity keyInfo0 = new DummyConceptEntity(aKey0,
 583                 UUID.fromString(UUID0), DESCRIPTION0);
 584         final DummyConceptEntity keyInfo1 = new DummyConceptEntity(aKey1,
 585                 UUID.fromString(UUID1), DESCRIPTION1);
 586         final DummyConceptEntity keyInfo2 = new DummyConceptEntity(aKey2,
 587                 UUID.fromString(UUID2), DESCRIPTION2);
 588         final DummyConceptEntity keyInfo3 = new DummyConceptEntity(bKey0,
 589                 UUID.fromString(UUID0), DESCRIPTION0);
 590         final DummyConceptEntity keyInfo4 = new DummyConceptEntity(bKey1,
 591                 UUID.fromString(UUID1), DESCRIPTION1);
 592         final DummyConceptEntity keyInfo5 = new DummyConceptEntity(bKey2,
 593                 UUID.fromString(UUID2), DESCRIPTION2);
 594
 595         pfDao.create(keyInfo0);
 596         pfDao.create(keyInfo1);
 597         pfDao.create(keyInfo2);
 598         pfDao.create(keyInfo3);
 599         pfDao.create(keyInfo4);
 600         pfDao.create(keyInfo5);
 601
 602         assertThat(pfDao.getFiltered(DummyConceptEntity.class, null, null)).hasSize(6);
 603         assertThat(pfDao.getFiltered(DummyConceptEntity.class, "AAA0", null)).hasSize(3);
 604         assertThat(pfDao.getFiltered(DummyConceptEntity.class, "BBB0", null)).hasSize(3);
 605         assertThat(pfDao.getFiltered(DummyConceptEntity.class, "BBB0", VERSION003)).hasSize(1);
 606         assertThat(pfDao.getFiltered(DummyConceptEntity.class, null, VERSION003)).hasSize(6);
 607
 608         final PfTimestampKey atKey0 = new PfTimestampKey("AT-KEY0", VERSION001, TIMESTAMP0);
 609         final PfTimestampKey atKey1 = new PfTimestampKey("AT-KEY1", VERSION001, TIMESTAMP1);
 610         final PfTimestampKey atKey2 = new PfTimestampKey("AT-KEY2", VERSION001, TIMESTAMP2);
 611         final DummyTimestampEntity tkeyInfo0 = new DummyTimestampEntity(atKey0, 200.0);
 612         final DummyTimestampEntity tkeyInfo1 = new DummyTimestampEntity(atKey1, 200.1);
 613         final DummyTimestampEntity tkeyInfo2 = new DummyTimestampEntity(atKey2, 200.2);
 614
 615         pfDao.create(tkeyInfo0);
 616         pfDao.create(tkeyInfo1);
 617         pfDao.create(tkeyInfo2);
 618
 619
 620         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 621                         PfFilterParameters.builder().name("AT-KEY0").version(VERSION001).build())).hasSize(1);
 622         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().name("AT-KEY0").build()))
 623                         .hasSize(1);
 624         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().version(VERSION001)
 625                         .startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
 626         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().name("AT-KEY0")
 627                         .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
 628         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 629                         PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
 630         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 631                         PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
 632         assertThat(pfDao.getFiltered(DummyTimestampEntity.class, PfFilterParameters.builder().version(VERSION001)
 633                         .startTime(TIMESTAMP0).endTime(TIMESTAMP2).sortOrder("DESC").recordNum(2).build())).hasSize(2);
 634
 635         Map<String, Object> filterMap = new HashMap<>();
 636         filterMap.put("doubleValue", 200.1);
 637         assertThat(pfDao.getFiltered(DummyTimestampEntity.class,
 638                         PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);
 639     }
 640
 641     private void testgetFilteredOps2() {
 642         Map<String, Object> filterMap = new HashMap<>();
 643         filterMap.put("doubleValue", 200.1);
 644
 645         final PfGeneratedIdKey agKey0 = new PfGeneratedIdKey("AT-KEY0", VERSION001);
 646         final PfGeneratedIdKey agKey1 = new PfGeneratedIdKey("AT-KEY1", VERSION001);
 647         final PfGeneratedIdKey agKey2 = new PfGeneratedIdKey("AT-KEY2", VERSION001);
 648         final DummyGeneratedIdEntity gkeyInfo0 = new DummyGeneratedIdEntity(agKey0, Date.from(TIMESTAMP0), 200.0);
 649         final DummyGeneratedIdEntity gkeyInfo1 = new DummyGeneratedIdEntity(agKey1, Date.from(TIMESTAMP1), 200.1);
 650         final DummyGeneratedIdEntity gkeyInfo2 = new DummyGeneratedIdEntity(agKey2, Date.from(TIMESTAMP2), 200.2);
 651
 652         pfDao.create(gkeyInfo0);
 653         pfDao.create(gkeyInfo1);
 654         pfDao.create(gkeyInfo2);
 655
 656
 657         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
 658                         PfFilterParameters.builder().name("AT-KEY0").version(VERSION001).build())).hasSize(1);
 659         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
 660                         PfFilterParameters.builder().name("AT-KEY0").build())).hasSize(1);
 661         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class, PfFilterParameters.builder().version(VERSION001)
 662                         .startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
 663         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class, PfFilterParameters.builder().name("AT-KEY0")
 664                         .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
 665         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
 666                         PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
 667         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
 668                         PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
 669         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class, PfFilterParameters.builder().version(VERSION001)
 670                         .startTime(TIMESTAMP0).endTime(TIMESTAMP2).sortOrder("DESC").recordNum(2).build())).hasSize(2);
 671
 672         assertThat(pfDao.getFiltered(DummyGeneratedIdEntity.class,
 673                         PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);
 674     }
 675
 676     private void testgetFilteredOps3() {
 677         Map<String, Object> filterMap = new HashMap<>();
 678         filterMap.put("localName", "AT-KEY0");
 679
 680         final PfConceptKey owner0Key = new PfConceptKey("Owner0", VERSION001);
 681         final PfConceptKey owner1Key = new PfConceptKey("Owner1", VERSION001);
 682         final PfConceptKey owner2Key = new PfConceptKey("Owner2", VERSION001);
 683         final PfReferenceTimestampKey arKey0 = new PfReferenceTimestampKey(owner0Key, "AT-KEY0", TIMESTAMP0);
 684         final PfReferenceTimestampKey arKey1 = new PfReferenceTimestampKey(owner1Key, "AT-KEY1", TIMESTAMP1);;
 685         final PfReferenceTimestampKey arKey2 = new PfReferenceTimestampKey(owner2Key, "AT-KEY2", TIMESTAMP2);
 686         final DummyReferenceTimestampEntity rkeyInfo0 = new DummyReferenceTimestampEntity(arKey0);
 687         final DummyReferenceTimestampEntity rkeyInfo1 = new DummyReferenceTimestampEntity(arKey1);
 688         final DummyReferenceTimestampEntity rkeyInfo2 = new DummyReferenceTimestampEntity(arKey2);
 689
 690         pfDao.create(rkeyInfo0);
 691         pfDao.create(rkeyInfo1);
 692         pfDao.create(rkeyInfo2);
 693
 694
 695         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 696                         PfFilterParameters.builder().name("Owner0").version(VERSION001).build())).hasSize(1);
 697         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 698                         PfFilterParameters.builder().name("Owner0").build())).hasSize(1);
 699         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class, PfFilterParameters.builder()
 700                         .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(3);
 701         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class, PfFilterParameters.builder().name("Owner0")
 702                         .version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2).build())).hasSize(1);
 703         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 704                         PfFilterParameters.builder().version(VERSION001).endTime(TIMESTAMP2).build())).hasSize(3);
 705         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 706                         PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).build())).hasSize(3);
 707         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 708                         PfFilterParameters.builder().version(VERSION001).startTime(TIMESTAMP0).endTime(TIMESTAMP2)
 709                                         .sortOrder("DESC").recordNum(2).build())).hasSize(2);
 710
 711         assertThat(pfDao.getFiltered(DummyReferenceTimestampEntity.class,
 712                         PfFilterParameters.builder().filterMap(filterMap).build())).hasSize(1);
 713     }
 714 }