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