music-core/src/test/java/org/onap/music/main/MusicCoreTest.java

   1 /*******************************************************************************
   2  * ============LICENSE_START========================================== org.onap.music
   3  * =================================================================== Copyright (c) 2019 AT&T
   4  * Intellectual Property ===================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   6  * in compliance with the License. You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software distributed under the License
  11  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  12  * or implied. See the License for the specific language governing permissions and limitations under
  13  * the License.
  14  *
  15  * ============LICENSE_END=============================================
  16  * ====================================================================
  17  *******************************************************************************/
  18
  19 package org.onap.music.main;
  20
  21 import static org.junit.Assert.assertEquals;
  22 import java.util.HashMap;
  23 import java.util.List;
  24 import java.util.Map;
  25 import javax.ws.rs.core.MultivaluedMap;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28 import org.mockito.Mockito;
  29 import org.mockito.internal.util.reflection.FieldSetter;
  30 import org.onap.music.datastore.Condition;
  31 import org.onap.music.datastore.PreparedQueryObject;
  32 import org.onap.music.datastore.jsonobjects.JsonDelete;
  33 import org.onap.music.datastore.jsonobjects.JsonIndex;
  34 import org.onap.music.datastore.jsonobjects.JsonInsert;
  35 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
  36 import org.onap.music.datastore.jsonobjects.JsonSelect;
  37 import org.onap.music.datastore.jsonobjects.JsonTable;
  38 import org.onap.music.datastore.jsonobjects.JsonUpdate;
  39 import org.onap.music.exceptions.MusicLockingException;
  40 import org.onap.music.exceptions.MusicQueryException;
  41 import org.onap.music.exceptions.MusicServiceException;
  42 import org.onap.music.lockingservice.cassandra.CassaLockStore;
  43 import org.onap.music.lockingservice.cassandra.LockType;
  44 import org.onap.music.lockingservice.cassandra.MusicLockState;
  45 import org.onap.music.service.MusicCoreService;
  46 import com.datastax.driver.core.ResultSet;
  47
  48 public class MusicCoreTest {
  49
  50     MusicCore mCore;
  51     MusicCoreService musicCore;
  52     CassaLockStore mLockHandle;
  53
  54     @Before
  55     public void setup() {
  56         mCore = new MusicCore();
  57         musicCore = Mockito.mock(MusicCoreService.class);
  58         mLockHandle = Mockito.mock(CassaLockStore.class);
  59         try {
  60             FieldSetter.setField(mCore, mCore.getClass().getDeclaredField("musicCore"), musicCore);
  61         } catch (NoSuchFieldException e) {
  62             // TODO Auto-generated catch block
  63             e.printStackTrace();
  64         } catch (SecurityException e) {
  65             // TODO Auto-generated catch block
  66             e.printStackTrace();
  67         }
  68     }
  69
  70     @Test
  71     public void testAcquireLock() throws MusicLockingException, MusicQueryException, MusicServiceException {
  72         ReturnType returnType = Mockito.mock(ReturnType.class);
  73         ReturnType result = null;
  74         Mockito.when(musicCore.acquireLock(Mockito.any(), Mockito.any())).thenReturn(returnType);
  75         result = MusicCore.acquireLock("key1", "lockid1");
  76         assertEquals(returnType, result);
  77     }
  78
  79     @Test
  80     public void testacquireLockWithLease() throws MusicLockingException, MusicQueryException, MusicServiceException {
  81         ReturnType returnType = Mockito.mock(ReturnType.class);
  82         ReturnType result = null;
  83         Mockito.when(musicCore.acquireLockWithLease(Mockito.anyString(), Mockito.anyString(), Mockito.anyLong()))
  84                 .thenReturn(returnType);
  85         result = MusicCore.acquireLockWithLease("key1", "lockid1", 100L);
  86         assertEquals(returnType, result);
  87     }
  88
  89     @Test
  90     public void testCreateLockReferenceAtomic() throws MusicLockingException {
  91         String result = null;
  92         Mockito.when(musicCore.createLockReferenceAtomic(Mockito.any())).thenReturn("lockreference1");
  93         result = MusicCore.createLockReferenceAtomic("key2");
  94         assertEquals("lockreference1", result);
  95     }
  96
  97     @Test
  98     public void testCreateLockReference() throws MusicLockingException {
  99         String result = null;
 100         Mockito.when(musicCore.createLockReference(Mockito.any(), Mockito.any())).thenReturn("lockreference2");
 101         result = MusicCore.createLockReference("key3", "owner3");
 102         assertEquals("lockreference2", result);
 103     }
 104
 105     @Test
 106     public void testCreateLockReferenceAtomic2() throws MusicLockingException {
 107         String result = null;
 108         Mockito.when(musicCore.createLockReferenceAtomic(Mockito.any(), Mockito.any())).thenReturn("lockreference3");
 109         result = MusicCore.createLockReferenceAtomic("key4", LockType.READ);
 110         assertEquals("lockreference3", result);
 111     }
 112
 113     @Test
 114     public void testCreateLockReference2() throws MusicLockingException {
 115         String result = null;
 116         Mockito.when(musicCore.createLockReference(Mockito.any(), Mockito.any(), Mockito.any()))
 117                 .thenReturn("lockreference4");
 118         result = MusicCore.createLockReference("key4", LockType.READ, "owner4");
 119         assertEquals("lockreference4", result);
 120     }
 121
 122     @Test
 123     public void testCreateTable() throws MusicServiceException {
 124         ResultType resultType = Mockito.mock(ResultType.class);
 125         ResultType result = null;
 126         Mockito.when(musicCore.createTable(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
 127                 .thenReturn(resultType);
 128         result = MusicCore.createTable("keyspace1", "table1", new PreparedQueryObject(), "consistency");
 129         assertEquals(resultType, result);
 130     }
 131
 132     @Test
 133     public void testQuorumGet() {
 134         ResultSet rs = Mockito.mock(ResultSet.class);
 135         Mockito.when(musicCore.quorumGet(Mockito.any())).thenReturn(rs);
 136         assertEquals(rs, MusicCore.quorumGet(new PreparedQueryObject()));
 137     }
 138
 139     @Test
 140     public void testWhoseTurnIsIt() {
 141         Mockito.when(musicCore.whoseTurnIsIt(Mockito.any())).thenReturn("turn");
 142         assertEquals("turn", MusicCore.whoseTurnIsIt("key5"));
 143     }
 144
 145     @Test
 146     public void testGetCurrentLockHolders() {
 147         List<String> result = Mockito.mock(List.class);
 148         Mockito.when(musicCore.getCurrentLockHolders(Mockito.any())).thenReturn(result);
 149         assertEquals(result, MusicCore.getCurrentLockHolders("key6"));
 150     }
 151
 152     @Test
 153     public void testPromoteLock() throws MusicLockingException {
 154         ReturnType returnType = Mockito.mock(ReturnType.class);
 155         ReturnType result = null;
 156         Mockito.when(musicCore.promoteLock(Mockito.any())).thenReturn(returnType);
 157         result = MusicCore.promoteLock("lockid2");
 158         assertEquals(returnType, result);
 159     }
 160
 161     @Test
 162     public void testEventualPut() {
 163         ReturnType returnType = Mockito.mock(ReturnType.class);
 164         Mockito.when(musicCore.eventualPut(Mockito.any())).thenReturn(returnType);
 165         assertEquals(returnType, MusicCore.eventualPut(new PreparedQueryObject()));
 166     }
 167
 168     @Test
 169     public void testEventualPut_nb() {
 170         ReturnType returnType = Mockito.mock(ReturnType.class);
 171         Mockito.when(musicCore.eventualPut_nb(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
 172                 .thenReturn(returnType);
 173         assertEquals(returnType,
 174                 MusicCore.eventualPut_nb(new PreparedQueryObject(), "keyspace2", "table2", "primarykey1"));
 175     }
 176
 177     @Test
 178     public void testCriticalPut() {
 179         ReturnType returnType = Mockito.mock(ReturnType.class);
 180         Mockito.when(musicCore.criticalPut(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
 181                 Mockito.any())).thenReturn(returnType);
 182         assertEquals(returnType, MusicCore.criticalPut("keyspace3", "table3", "primarykey2", new PreparedQueryObject(),
 183                 "lockreference2", new Condition(new HashMap(), new PreparedQueryObject())));
 184     }
 185
 186     @Test
 187     public void testNonKeyRelatedPut() throws MusicServiceException, MusicQueryException {
 188         ResultType resultType = Mockito.mock(ResultType.class);
 189         ResultType result = null;
 190         Mockito.when(musicCore.nonKeyRelatedPut(Mockito.any(), Mockito.any())).thenReturn(resultType);
 191         result = MusicCore.nonKeyRelatedPut(new PreparedQueryObject(), "consistency2");
 192         assertEquals(resultType, result);
 193     }
 194
 195     @Test
 196     public void testGet() throws MusicServiceException {
 197         ResultSet rs = Mockito.mock(ResultSet.class);
 198         ResultSet result = null;
 199         Mockito.when(musicCore.get(Mockito.any())).thenReturn(rs);
 200         result = MusicCore.get(new PreparedQueryObject());
 201         assertEquals(rs, result);
 202     }
 203
 204     @Test
 205     public void testCriticalGet() throws MusicServiceException {
 206         ResultSet rs = Mockito.mock(ResultSet.class);
 207         ResultSet result = null;
 208         Mockito.when(musicCore.criticalGet(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
 209                 .thenReturn(rs);
 210         result = MusicCore.criticalGet("keyspace4", "table4", "primarykey3", new PreparedQueryObject(),
 211                 "lockreference3");
 212         assertEquals(rs, result);
 213     }
 214
 215     @Test
 216     public void testAtomicPut() throws MusicLockingException, MusicQueryException, MusicServiceException {
 217         ReturnType returnType = Mockito.mock(ReturnType.class);
 218         ReturnType result = null;
 219         Mockito.when(musicCore.atomicPut(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
 220                 .thenReturn(returnType);
 221         result = MusicCore.atomicPut("keyspace5", "table5", "primarykey4", new PreparedQueryObject(),
 222                 new Condition(new HashMap(), new PreparedQueryObject()));
 223         assertEquals(returnType, result);
 224     }
 225
 226     @Test
 227     public void testAtomicGet() throws MusicServiceException, MusicLockingException, MusicQueryException {
 228         ResultSet rs = Mockito.mock(ResultSet.class);
 229         ResultSet result = null;
 230         Mockito.when(musicCore.atomicGet(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(rs);
 231         result = MusicCore.atomicGet("keyspace5", "table5", "primarykey4", new PreparedQueryObject());
 232         assertEquals(rs, result);
 233     }
 234
 235     @Test
 236     public void testGetLockQueue() throws MusicServiceException, MusicQueryException, MusicLockingException {
 237         List<String> result = Mockito.mock(List.class);
 238         List<String> rst = null;
 239         Mockito.when(musicCore.getLockQueue(Mockito.any())).thenReturn(result);
 240         rst = MusicCore.getLockQueue("key5");
 241         assertEquals(result, rst);
 242     }
 243
 244     @Test
 245     public void testGetLockQueueSize() throws MusicServiceException, MusicQueryException, MusicLockingException {
 246         long result = 0L;
 247         Mockito.when(musicCore.getLockQueueSize(Mockito.any())).thenReturn(100L);
 248         result = MusicCore.getLockQueueSize("key6");
 249         assertEquals(100L, result);
 250     }
 251
 252     @Test
 253     public void testatomicPutWithDeleteLock() throws MusicLockingException {
 254         ReturnType returnType = Mockito.mock(ReturnType.class);
 255         ReturnType result = null;
 256         Mockito.when(musicCore.atomicPutWithDeleteLock(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
 257                 Mockito.any())).thenReturn(returnType);
 258         result = MusicCore.atomicPutWithDeleteLock("keyspace5", "table5", "primarykey4", new PreparedQueryObject(),
 259                 new Condition(new HashMap(), new PreparedQueryObject()));
 260         assertEquals(returnType, result);
 261     }
 262
 263     @Test
 264     public void testAtomicGetWithDeleteLock() throws MusicServiceException, MusicLockingException {
 265         ResultSet rs = Mockito.mock(ResultSet.class);
 266         ResultSet result = null;
 267         Mockito.when(musicCore.atomicGetWithDeleteLock(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
 268                 .thenReturn(rs);
 269         result = MusicCore.atomicGetWithDeleteLock("keyspace5", "table5", "primarykey4", new PreparedQueryObject());
 270         assertEquals(rs, result);
 271     }
 272
 273     @Test
 274     public void testValidateLock() {
 275         Map<String, Object> map = Mockito.mock(Map.class);
 276         Mockito.when(musicCore.validateLock(Mockito.any())).thenReturn(map);
 277         assertEquals(map, MusicCore.validateLock("lockname"));
 278     }
 279
 280     @Test
 281     public void testReleaseLock() throws MusicLockingException {
 282         MusicLockState musicLockState = Mockito.mock(MusicLockState.class);
 283         MusicLockState result = null;
 284         Mockito.when(musicCore.releaseLock(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(musicLockState);
 285         result = MusicCore.releaseLock("lockid", true);
 286         assertEquals(musicLockState, result);
 287     }
 288
 289     @Test
 290     public void testReleaseAllLocksForOwner() throws MusicLockingException, MusicServiceException, MusicQueryException {
 291         List<String> result = Mockito.mock(List.class);
 292         List<String> rst = null;
 293         Mockito.when(musicCore.releaseAllLocksForOwner(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(result);
 294         rst = MusicCore.releaseAllLocksForOwner("owner2", "keyspace6", "table6");
 295         assertEquals(result, rst);
 296     }
 297
 298     @Test
 299     public void testCreateKeyspace() throws MusicServiceException, MusicQueryException {
 300         ResultType resultType = Mockito.mock(ResultType.class);
 301         ResultType result = null;
 302         Mockito.when(musicCore.createKeyspace(Mockito.any(), Mockito.any())).thenReturn(resultType);
 303         result = MusicCore.createKeyspace(new JsonKeySpace(), "consistency3");
 304         assertEquals(resultType, result);
 305     }
 306
 307     @Test
 308     public void testDropKeyspace() throws MusicServiceException, MusicQueryException {
 309         ResultType resultType = Mockito.mock(ResultType.class);
 310         ResultType result = null;
 311         Mockito.when(musicCore.dropKeyspace(Mockito.any(), Mockito.any())).thenReturn(resultType);
 312         result = MusicCore.dropKeyspace(new JsonKeySpace(), "consistency4");
 313         assertEquals(resultType, result);
 314     }
 315
 316     @Test
 317     public void testCreateTable2() throws MusicServiceException, MusicQueryException {
 318         ResultType resultType = Mockito.mock(ResultType.class);
 319         ResultType result = null;
 320         Mockito.when(musicCore.createTable(Mockito.any(), Mockito.any())).thenReturn(resultType);
 321         result = MusicCore.createTable(new JsonTable(), "consistency5");
 322         assertEquals(resultType, result);
 323     }
 324
 325     @Test
 326     public void testDropTable() throws MusicServiceException, MusicQueryException {
 327         ResultType resultType = Mockito.mock(ResultType.class);
 328         ResultType result = null;
 329         Mockito.when(musicCore.dropTable(Mockito.any(), Mockito.any())).thenReturn(resultType);
 330         result = MusicCore.dropTable(new JsonTable(), "consistency5");
 331         assertEquals(resultType, result);
 332     }
 333
 334     @Test
 335     public void testCreateIndex() throws MusicServiceException, MusicQueryException {
 336         ResultType resultType = Mockito.mock(ResultType.class);
 337         ResultType result = null;
 338         Mockito.when(musicCore.createIndex(Mockito.any(), Mockito.any())).thenReturn(resultType);
 339         result = MusicCore.createIndex(new JsonIndex("indexName", "keyspace7", "table7", "field"), "consistency6");
 340         assertEquals(resultType, result);
 341     }
 342
 343     @Test
 344     public void testSelect() throws MusicServiceException, MusicQueryException {
 345         ResultSet rs = Mockito.mock(ResultSet.class);
 346         ResultSet result = null;
 347         Mockito.when(musicCore.select(Mockito.any(), Mockito.any())).thenReturn(rs);
 348         MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
 349         result = MusicCore.select(new JsonSelect(), map);
 350         assertEquals(rs, result);
 351     }
 352
 353     @Test
 354     public void testSelectCritical() throws MusicLockingException, MusicQueryException, MusicServiceException {
 355         ResultSet rs = Mockito.mock(ResultSet.class);
 356         ResultSet result = null;
 357         Mockito.when(musicCore.selectCritical(Mockito.any(), Mockito.any())).thenReturn(rs);
 358         MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
 359         result = MusicCore.selectCritical(new JsonInsert(), map);
 360         assertEquals(rs, result);
 361     }
 362
 363     @Test
 364     public void testInsertIntoTable() throws MusicLockingException, MusicQueryException, MusicServiceException {
 365         ReturnType returnType = Mockito.mock(ReturnType.class);
 366         ReturnType result = null;
 367         Mockito.when(musicCore.insertIntoTable(Mockito.any())).thenReturn(returnType);
 368         result = MusicCore.insertIntoTable(new JsonInsert());
 369         assertEquals(returnType, result);
 370     }
 371
 372     @Test
 373     public void testUpdateTable() throws MusicLockingException, MusicQueryException, MusicServiceException {
 374         ReturnType returnType = Mockito.mock(ReturnType.class);
 375         ReturnType result = null;
 376         Mockito.when(musicCore.updateTable(Mockito.any(), Mockito.any())).thenReturn(returnType);
 377         MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
 378         result = MusicCore.updateTable(new JsonUpdate(), map);
 379         assertEquals(returnType, result);
 380     }
 381
 382     @Test
 383     public void testDeleteFromTable() throws MusicLockingException, MusicQueryException, MusicServiceException {
 384         ReturnType returnType = Mockito.mock(ReturnType.class);
 385         ReturnType result = null;
 386         MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
 387         Mockito.when(musicCore.deleteFromTable(Mockito.any(), Mockito.any())).thenReturn(returnType);
 388         result = MusicCore.deleteFromTable(new JsonDelete(), map);
 389         assertEquals(returnType, result);
 390     }
 391 }