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

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