Merge "JUnit test case coverage for Condition.java, JsonLock.java, MusicLockState.java, MusicCore.java Issue-ID: MUSIC-521"

5 files changed, 601 insertions, 3 deletions

diff --git a/music-core/src/main/java/org/onap/music/datastore/Condition.java b/music-core/src/main/java/org/onap/music/datastore/Condition.java
index 6587748e..c17d9c07 100644
--- a/music-core/src/main/java/org/onap/music/datastore/Condition.java
+++ b/music-core/src/main/java/org/onap/music/datastore/Condition.java
@@ -23,7 +23,7 @@
 package org.onap.music.datastore;
 
 import java.util.Map;
-
+import org.onap.music.exceptions.MusicServiceException;
 import org.onap.music.main.MusicCore;
 
 import com.datastax.driver.core.ResultSet;
@@ -40,7 +40,7 @@ public class Condition {
 
         public boolean testCondition() throws Exception {
             // first generate the row
-            ResultSet results = MusicCore.quorumGet(selectQueryForTheRow);
+            ResultSet results = quorumGet(selectQueryForTheRow);
             Row row = null;
             if(results != null) {
                 row = results.one();
@@ -48,6 +48,16 @@ public class Condition {
             if(row == null) {
                 throw new Exception(" No data found to update");
             }
-            return MusicDataStoreHandle.getDSHandle().doesRowSatisfyCondition(row, conditions);
+            return getDSHandle().doesRowSatisfyCondition(row, conditions);
+        }
+        
+        /* For JUnit testing only */
+        public ResultSet quorumGet(PreparedQueryObject selectQueryForTheRow) {
+            return MusicCore.quorumGet(selectQueryForTheRow);
+        }
+        
+        /* For JUnit testing only */
+        public MusicDataStore getDSHandle() throws MusicServiceException {
+            return MusicDataStoreHandle.getDSHandle();
         }
     }
\ No newline at end of file
diff --git a/music-core/src/test/java/org/onap/music/datastore/ConditionTest.java b/music-core/src/test/java/org/onap/music/datastore/ConditionTest.java
new file mode 100644
index 00000000..2aac62af
--- /dev/null
+++ b/music-core/src/test/java/org/onap/music/datastore/ConditionTest.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * ============LICENSE_START========================================== org.onap.music
+ * =================================================================== Copyright (c) 2019 AT&T
+ * Intellectual Property ===================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ * 
+ * ============LICENSE_END=============================================
+ * ====================================================================
+ *******************************************************************************/
+
+package org.onap.music.datastore;
+
+import org.onap.music.datastore.Condition;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.exceptions.MusicServiceException;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Mockito.spy;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.Spy;
+
+public class ConditionTest {
+
+    @Spy
+    private Condition condition;
+    private Map<String, Object> conditions;
+    private PreparedQueryObject selectQueryForTheRow;
+
+    @Before
+    public void setup() {
+        conditions = Mockito.mock(Map.class);
+        selectQueryForTheRow = Mockito.mock(PreparedQueryObject.class);
+        condition = spy(new Condition(conditions, selectQueryForTheRow));
+    }
+
+    @Test
+    public void testCondition() throws Exception {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        Row row = Mockito.mock(Row.class);
+        MusicDataStore dsHandle = Mockito.mock(MusicDataStore.class);
+        Mockito.when(rs.one()).thenReturn(row);
+        Mockito.doReturn(rs).when(condition).quorumGet(Mockito.any());
+        boolean result = false;
+        Mockito.when(dsHandle.doesRowSatisfyCondition(Mockito.any(), Mockito.any())).thenReturn(true);
+        Mockito.doReturn(dsHandle).when(condition).getDSHandle();
+        result = condition.testCondition();
+        assertEquals(true, result);
+    }
+}
diff --git a/music-core/src/test/java/org/onap/music/datastore/jsonobjects/JsonLockTest.java b/music-core/src/test/java/org/onap/music/datastore/jsonobjects/JsonLockTest.java
new file mode 100644
index 00000000..75db75e5
--- /dev/null
+++ b/music-core/src/test/java/org/onap/music/datastore/jsonobjects/JsonLockTest.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2019 AT&T Intellectual Property
+ * ===================================================================
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *  
+ * ============LICENSE_END=============================================
+ * ====================================================================
+ *******************************************************************************/
+
+package org.onap.music.datastore.jsonobjects;
+
+import static org.junit.Assert.assertEquals;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.lockingservice.cassandra.LockType;
+
+public class JsonLockTest {
+
+    JsonLock jsonLock;
+    
+    @Before
+    public void setup() {
+        jsonLock = new JsonLock();
+    }
+    
+    @Test
+    public void testSetLockType() {
+        jsonLock.setLockType(LockType.READ);
+        assertEquals(LockType.READ, jsonLock.getLocktype());
+        
+        jsonLock.setLockType(LockType.WRITE);
+        assertEquals(LockType.WRITE, jsonLock.getLocktype());
+        
+        jsonLock.setLockType(LockType.PROMOTING);
+        assertEquals(LockType.PROMOTING, jsonLock.getLocktype());
+    }
+}
diff --git a/music-core/src/test/java/org/onap/music/lockingservice/cassandra/MusicLockStateTest.java b/music-core/src/test/java/org/onap/music/lockingservice/cassandra/MusicLockStateTest.java
new file mode 100644
index 00000000..e5b655bd
--- /dev/null
+++ b/music-core/src/test/java/org/onap/music/lockingservice/cassandra/MusicLockStateTest.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2019 AT&T Intellectual Property
+ * ===================================================================
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ *  
+ * ============LICENSE_END=============================================
+ * ====================================================================
+ *******************************************************************************/
+
+package org.onap.music.lockingservice.cassandra;
+
+import static org.junit.Assert.assertEquals;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.lockingservice.cassandra.MusicLockState.LockStatus;
+
+public class MusicLockStateTest {
+    
+    MusicLockState musicLockState;
+    
+    @Before
+    public void setup() {
+        musicLockState = new MusicLockState(LockStatus.LOCKED, "", true);
+    }
+    
+    @Test
+    public void testGetLeasePeriod() {
+        musicLockState.setLeasePeriod(200L);
+        assertEquals(200L, musicLockState.getLeasePeriod());
+    }
+    
+    @Test
+    public void testIsNeedToSyncQuorum() {
+        assertEquals(true, musicLockState.isNeedToSyncQuorum());
+    }
+    
+    @Test
+    public void testGetLeaseStartTime() {
+        musicLockState.setLeaseStartTime(200L);
+        assertEquals(200L, musicLockState.getLeaseStartTime());
+    }
+    
+    @Test
+    public void testGetLockStatus() {
+        musicLockState.setLockStatus(LockStatus.LOCKED);
+        assertEquals(LockStatus.LOCKED, musicLockState.getLockStatus());
+    }
+    
+    @Test
+    public void testGetLockHolder() {
+        musicLockState.setLockHolder("lockHolder");
+        assertEquals("lockHolder", musicLockState.getLockHolder());
+    }
+    
+    @Test
+    public void testGetErrorMessage() {
+        MusicLockState musicLockState2 = new MusicLockState("This is error message");
+        assertEquals("This is error message", musicLockState2.getErrorMessage());
+    }
+    
+    @Test
+    public void testSerialize() {
+        byte[] serializedBytes = musicLockState.serialize();
+        MusicLockState musicLockState3 = musicLockState.deSerialize(serializedBytes);
+        assertEquals(musicLockState.getLeasePeriod(),musicLockState3.getLeasePeriod());
+        assertEquals(musicLockState.isNeedToSyncQuorum(),musicLockState3.isNeedToSyncQuorum());
+        assertEquals(musicLockState.getLeaseStartTime(),musicLockState3.getLeaseStartTime());
+        assertEquals(musicLockState.getLockStatus(),musicLockState3.getLockStatus());
+        assertEquals(musicLockState.getLockHolder(),musicLockState3.getLockHolder());
+        assertEquals(musicLockState.getErrorMessage(),musicLockState3.getErrorMessage());
+    }
+    
+}
diff --git a/music-core/src/test/java/org/onap/music/main/MusicCoreTest.java b/music-core/src/test/java/org/onap/music/main/MusicCoreTest.java
new file mode 100644
index 00000000..4714778b
--- /dev/null
+++ b/music-core/src/test/java/org/onap/music/main/MusicCoreTest.java
@@ -0,0 +1,391 @@
+/*******************************************************************************
+ * ============LICENSE_START========================================== org.onap.music
+ * =================================================================== Copyright (c) 2019 AT&T
+ * Intellectual Property ===================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ * 
+ * ============LICENSE_END=============================================
+ * ====================================================================
+ *******************************************************************************/
+
+package org.onap.music.main;
+
+import static org.junit.Assert.assertEquals;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.ws.rs.core.MultivaluedMap;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.mockito.internal.util.reflection.FieldSetter;
+import org.onap.music.datastore.Condition;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonIndex;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+import org.onap.music.datastore.jsonobjects.JsonSelect;
+import org.onap.music.datastore.jsonobjects.JsonTable;
+import org.onap.music.datastore.jsonobjects.JsonUpdate;
+import org.onap.music.exceptions.MusicLockingException;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.lockingservice.cassandra.CassaLockStore;
+import org.onap.music.lockingservice.cassandra.LockType;
+import org.onap.music.lockingservice.cassandra.MusicLockState;
+import org.onap.music.service.MusicCoreService;
+import com.datastax.driver.core.ResultSet;
+
+public class MusicCoreTest {
+
+    MusicCore mCore;
+    MusicCoreService musicCore;
+    CassaLockStore mLockHandle;
+
+    @Before
+    public void setup() {
+        mCore = new MusicCore();
+        musicCore = Mockito.mock(MusicCoreService.class);
+        mLockHandle = Mockito.mock(CassaLockStore.class);
+        try {
+            FieldSetter.setField(mCore, mCore.getClass().getDeclaredField("musicCore"), musicCore);
+        } catch (NoSuchFieldException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        } catch (SecurityException e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+    }
+
+    @Test
+    public void testAcquireLock() throws MusicLockingException, MusicQueryException, MusicServiceException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        Mockito.when(musicCore.acquireLock(Mockito.any(), Mockito.any())).thenReturn(returnType);
+        result = MusicCore.acquireLock("key1", "lockid1");
+        assertEquals(returnType, result);
+    }
+
+    @Test
+    public void testacquireLockWithLease() throws MusicLockingException, MusicQueryException, MusicServiceException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        Mockito.when(musicCore.acquireLockWithLease(Mockito.anyString(), Mockito.anyString(), Mockito.anyLong()))
+                .thenReturn(returnType);
+        result = MusicCore.acquireLockWithLease("key1", "lockid1", 100L);
+        assertEquals(returnType, result);
+    }
+
+    @Test
+    public void testCreateLockReferenceAtomic() throws MusicLockingException {
+        String result = null;
+        Mockito.when(musicCore.createLockReferenceAtomic(Mockito.any())).thenReturn("lockreference1");
+        result = MusicCore.createLockReferenceAtomic("key2");
+        assertEquals("lockreference1", result);
+    }
+
+    @Test
+    public void testCreateLockReference() throws MusicLockingException {
+        String result = null;
+        Mockito.when(musicCore.createLockReference(Mockito.any(), Mockito.any())).thenReturn("lockreference2");
+        result = MusicCore.createLockReference("key3", "owner3");
+        assertEquals("lockreference2", result);
+    }
+
+    @Test
+    public void testCreateLockReferenceAtomic2() throws MusicLockingException {
+        String result = null;
+        Mockito.when(musicCore.createLockReferenceAtomic(Mockito.any(), Mockito.any())).thenReturn("lockreference3");
+        result = MusicCore.createLockReferenceAtomic("key4", LockType.READ);
+        assertEquals("lockreference3", result);
+    }
+
+    @Test
+    public void testCreateLockReference2() throws MusicLockingException {
+        String result = null;
+        Mockito.when(musicCore.createLockReference(Mockito.any(), Mockito.any(), Mockito.any()))
+                .thenReturn("lockreference4");
+        result = MusicCore.createLockReference("key4", LockType.READ, "owner4");
+        assertEquals("lockreference4", result);
+    }
+
+    @Test
+    public void testCreateTable() throws MusicServiceException {
+        ResultType resultType = Mockito.mock(ResultType.class);
+        ResultType result = null;
+        Mockito.when(musicCore.createTable(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
+                .thenReturn(resultType);
+        result = MusicCore.createTable("keyspace1", "table1", new PreparedQueryObject(), "consistency");
+        assertEquals(resultType, result);
+    }
+
+    @Test
+    public void testQuorumGet() {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        Mockito.when(musicCore.quorumGet(Mockito.any())).thenReturn(rs);
+        assertEquals(rs, MusicCore.quorumGet(new PreparedQueryObject()));
+    }
+
+    @Test
+    public void testWhoseTurnIsIt() {
+        Mockito.when(musicCore.whoseTurnIsIt(Mockito.any())).thenReturn("turn");
+        assertEquals("turn", MusicCore.whoseTurnIsIt("key5"));
+    }
+
+    @Test
+    public void testGetCurrentLockHolders() {
+        List<String> result = Mockito.mock(List.class);
+        Mockito.when(musicCore.getCurrentLockHolders(Mockito.any())).thenReturn(result);
+        assertEquals(result, MusicCore.getCurrentLockHolders("key6"));
+    }
+
+    @Test
+    public void testPromoteLock() throws MusicLockingException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        Mockito.when(musicCore.promoteLock(Mockito.any())).thenReturn(returnType);
+        result = MusicCore.promoteLock("lockid2");
+        assertEquals(returnType, result);
+    }
+
+    @Test
+    public void testEventualPut() {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        Mockito.when(musicCore.eventualPut(Mockito.any())).thenReturn(returnType);
+        assertEquals(returnType, MusicCore.eventualPut(new PreparedQueryObject()));
+    }
+
+    @Test
+    public void testEventualPut_nb() {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        Mockito.when(musicCore.eventualPut_nb(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
+                .thenReturn(returnType);
+        assertEquals(returnType,
+                MusicCore.eventualPut_nb(new PreparedQueryObject(), "keyspace2", "table2", "primarykey1"));
+    }
+
+    @Test
+    public void testCriticalPut() {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        Mockito.when(musicCore.criticalPut(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
+                Mockito.any())).thenReturn(returnType);
+        assertEquals(returnType, MusicCore.criticalPut("keyspace3", "table3", "primarykey2", new PreparedQueryObject(),
+                "lockreference2", new Condition(new HashMap(), new PreparedQueryObject())));
+    }
+
+    @Test
+    public void testNonKeyRelatedPut() throws MusicServiceException, MusicQueryException {
+        ResultType resultType = Mockito.mock(ResultType.class);
+        ResultType result = null;
+        Mockito.when(musicCore.nonKeyRelatedPut(Mockito.any(), Mockito.any())).thenReturn(resultType);
+        result = MusicCore.nonKeyRelatedPut(new PreparedQueryObject(), "consistency2");
+        assertEquals(resultType, result);
+    }
+
+    @Test
+    public void testGet() throws MusicServiceException {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        ResultSet result = null;
+        Mockito.when(musicCore.get(Mockito.any())).thenReturn(rs);
+        result = MusicCore.get(new PreparedQueryObject());
+        assertEquals(rs, result);
+    }
+
+    @Test
+    public void testCriticalGet() throws MusicServiceException {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        ResultSet result = null;
+        Mockito.when(musicCore.criticalGet(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
+                .thenReturn(rs);
+        result = MusicCore.criticalGet("keyspace4", "table4", "primarykey3", new PreparedQueryObject(),
+                "lockreference3");
+        assertEquals(rs, result);
+    }
+
+    @Test
+    public void testAtomicPut() throws MusicLockingException, MusicQueryException, MusicServiceException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        Mockito.when(musicCore.atomicPut(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
+                .thenReturn(returnType);
+        result = MusicCore.atomicPut("keyspace5", "table5", "primarykey4", new PreparedQueryObject(),
+                new Condition(new HashMap(), new PreparedQueryObject()));
+        assertEquals(returnType, result);
+    }
+
+    @Test
+    public void testAtomicGet() throws MusicServiceException, MusicLockingException, MusicQueryException {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        ResultSet result = null;
+        Mockito.when(musicCore.atomicGet(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(rs);
+        result = MusicCore.atomicGet("keyspace5", "table5", "primarykey4", new PreparedQueryObject());
+        assertEquals(rs, result);
+    }
+
+    @Test
+    public void testGetLockQueue() throws MusicServiceException, MusicQueryException, MusicLockingException {
+        List<String> result = Mockito.mock(List.class);
+        List<String> rst = null;
+        Mockito.when(musicCore.getLockQueue(Mockito.any())).thenReturn(result);
+        rst = MusicCore.getLockQueue("key5");
+        assertEquals(result, rst);
+    }
+
+    @Test
+    public void testGetLockQueueSize() throws MusicServiceException, MusicQueryException, MusicLockingException {
+        long result = 0L;
+        Mockito.when(musicCore.getLockQueueSize(Mockito.any())).thenReturn(100L);
+        result = MusicCore.getLockQueueSize("key6");
+        assertEquals(100L, result);
+    }
+
+    @Test
+    public void testatomicPutWithDeleteLock() throws MusicLockingException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        Mockito.when(musicCore.atomicPutWithDeleteLock(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any(),
+                Mockito.any())).thenReturn(returnType);
+        result = MusicCore.atomicPutWithDeleteLock("keyspace5", "table5", "primarykey4", new PreparedQueryObject(),
+                new Condition(new HashMap(), new PreparedQueryObject()));
+        assertEquals(returnType, result);
+    }
+
+    @Test
+    public void testAtomicGetWithDeleteLock() throws MusicServiceException, MusicLockingException {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        ResultSet result = null;
+        Mockito.when(musicCore.atomicGetWithDeleteLock(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any()))
+                .thenReturn(rs);
+        result = MusicCore.atomicGetWithDeleteLock("keyspace5", "table5", "primarykey4", new PreparedQueryObject());
+        assertEquals(rs, result);
+    }
+
+    @Test
+    public void testValidateLock() {
+        Map<String, Object> map = Mockito.mock(Map.class);
+        Mockito.when(musicCore.validateLock(Mockito.any())).thenReturn(map);
+        assertEquals(map, MusicCore.validateLock("lockname"));
+    }
+
+    @Test
+    public void testReleaseLock() throws MusicLockingException {
+        MusicLockState musicLockState = Mockito.mock(MusicLockState.class);
+        MusicLockState result = null;
+        Mockito.when(musicCore.releaseLock(Mockito.anyString(), Mockito.anyBoolean())).thenReturn(musicLockState);
+        result = MusicCore.releaseLock("lockid", true);
+        assertEquals(musicLockState, result);
+    }
+
+    @Test
+    public void testReleaseAllLocksForOwner() throws MusicLockingException, MusicServiceException, MusicQueryException {
+        List<String> result = Mockito.mock(List.class);
+        List<String> rst = null;
+        Mockito.when(musicCore.releaseAllLocksForOwner(Mockito.any(), Mockito.any(), Mockito.any())).thenReturn(result);
+        rst = MusicCore.releaseAllLocksForOwner("owner2", "keyspace6", "table6");
+        assertEquals(result, rst);
+    }
+
+    @Test
+    public void testCreateKeyspace() throws MusicServiceException, MusicQueryException {
+        ResultType resultType = Mockito.mock(ResultType.class);
+        ResultType result = null;
+        Mockito.when(musicCore.createKeyspace(Mockito.any(), Mockito.any())).thenReturn(resultType);
+        result = MusicCore.createKeyspace(new JsonKeySpace(), "consistency3");
+        assertEquals(resultType, result);
+    }
+
+    @Test
+    public void testDropKeyspace() throws MusicServiceException, MusicQueryException {
+        ResultType resultType = Mockito.mock(ResultType.class);
+        ResultType result = null;
+        Mockito.when(musicCore.dropKeyspace(Mockito.any(), Mockito.any())).thenReturn(resultType);
+        result = MusicCore.dropKeyspace(new JsonKeySpace(), "consistency4");
+        assertEquals(resultType, result);
+    }
+
+    @Test
+    public void testCreateTable2() throws MusicServiceException, MusicQueryException {
+        ResultType resultType = Mockito.mock(ResultType.class);
+        ResultType result = null;
+        Mockito.when(musicCore.createTable(Mockito.any(), Mockito.any())).thenReturn(resultType);
+        result = MusicCore.createTable(new JsonTable(), "consistency5");
+        assertEquals(resultType, result);
+    }
+
+    @Test
+    public void testDropTable() throws MusicServiceException, MusicQueryException {
+        ResultType resultType = Mockito.mock(ResultType.class);
+        ResultType result = null;
+        Mockito.when(musicCore.dropTable(Mockito.any(), Mockito.any())).thenReturn(resultType);
+        result = MusicCore.dropTable(new JsonTable(), "consistency5");
+        assertEquals(resultType, result);
+    }
+
+    @Test
+    public void testCreateIndex() throws MusicServiceException, MusicQueryException {
+        ResultType resultType = Mockito.mock(ResultType.class);
+        ResultType result = null;
+        Mockito.when(musicCore.createIndex(Mockito.any(), Mockito.any())).thenReturn(resultType);
+        result = MusicCore.createIndex(new JsonIndex("indexName", "keyspace7", "table7", "field"), "consistency6");
+        assertEquals(resultType, result);
+    }
+
+    @Test
+    public void testSelect() throws MusicServiceException, MusicQueryException {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        ResultSet result = null;
+        Mockito.when(musicCore.select(Mockito.any(), Mockito.any())).thenReturn(rs);
+        MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
+        result = MusicCore.select(new JsonSelect(), map);
+        assertEquals(rs, result);
+    }
+
+    @Test
+    public void testSelectCritical() throws MusicLockingException, MusicQueryException, MusicServiceException {
+        ResultSet rs = Mockito.mock(ResultSet.class);
+        ResultSet result = null;
+        Mockito.when(musicCore.selectCritical(Mockito.any(), Mockito.any())).thenReturn(rs);
+        MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
+        result = MusicCore.selectCritical(new JsonInsert(), map);
+        assertEquals(rs, result);
+    }
+
+    @Test
+    public void testInsertIntoTable() throws MusicLockingException, MusicQueryException, MusicServiceException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        Mockito.when(musicCore.insertIntoTable(Mockito.any())).thenReturn(returnType);
+        result = MusicCore.insertIntoTable(new JsonInsert());
+        assertEquals(returnType, result);
+    }
+
+    @Test
+    public void testUpdateTable() throws MusicLockingException, MusicQueryException, MusicServiceException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        Mockito.when(musicCore.updateTable(Mockito.any(), Mockito.any())).thenReturn(returnType);
+        MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
+        result = MusicCore.updateTable(new JsonUpdate(), map);
+        assertEquals(returnType, result);
+    }
+
+    @Test
+    public void testDeleteFromTable() throws MusicLockingException, MusicQueryException, MusicServiceException {
+        ReturnType returnType = Mockito.mock(ReturnType.class);
+        ReturnType result = null;
+        MultivaluedMap<String, String> map = Mockito.mock(MultivaluedMap.class);
+        Mockito.when(musicCore.deleteFromTable(Mockito.any(), Mockito.any())).thenReturn(returnType);
+        result = MusicCore.deleteFromTable(new JsonDelete(), map);
+        assertEquals(returnType, result);
+    }
+}