Update Master to include jar folder.

This will put jar folder form separate branch into this where it
belongs and we can build properly for beijing. Cassablanca will
have a parent pom approach.

Change-Id: Ieae3fce5ab42faddf4964285533fdc59d8b963de
Issue-ID: MUSIC-79
Signed-off-by: Thomas Nelson Jr (arthurdent3) tn1381@att.com <tn1381@att.com>

19 files changed, 2942 insertions, 0 deletions

diff --git a/jar/src/test/java/org/onap/music/unittests/CassandraCQL.java b/jar/src/test/java/org/onap/music/unittests/CassandraCQL.java
new file mode 100644
index 00000000..a4c250c2
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/CassandraCQL.java
@@ -0,0 +1,256 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+/**
+ * @author srupane
+ * 
+ */
+
+import java.io.IOException;
+import java.math.BigInteger;
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import com.datastax.driver.core.Cluster;
+import com.datastax.driver.core.Session;
+import com.datastax.driver.core.exceptions.NoHostAvailableException;
+import org.apache.cassandra.exceptions.ConfigurationException;
+import org.apache.thrift.transport.TTransportException;
+import org.cassandraunit.utils.EmbeddedCassandraServerHelper;
+import org.onap.music.datastore.MusicDataStore;
+import org.onap.music.datastore.PreparedQueryObject;
+
+public class CassandraCQL {
+
+    public static final String createKeySpace =
+                    "CREATE KEYSPACE IF NOT EXISTS testCassa WITH replication = "
+                    +"{'class':'SimpleStrategy','replication_factor':1} AND durable_writes = true;";
+
+    public static final String dropKeyspace = "DROP KEYSPACE IF EXISTS testCassa";
+
+    public static final String createTableEmployees =
+                    "CREATE TABLE IF NOT EXISTS testCassa.employees "
+                    + "(vector_ts text,empId uuid,empName text,empSalary varint,address Map<text,text>,PRIMARY KEY (empName)) "
+                    + "WITH comment='Financial Info of employees' "
+                    + "AND compression={'sstable_compression':'DeflateCompressor','chunk_length_kb':64} "
+                    + "AND compaction={'class':'SizeTieredCompactionStrategy','min_threshold':6};";
+
+    public static final String insertIntoTablePrepared1 =
+                    "INSERT INTO testCassa.employees (vector_ts,empId,empName,empSalary) VALUES (?,?,?,?); ";
+
+    public static final String insertIntoTablePrepared2 =
+                    "INSERT INTO testCassa.employees (vector_ts,empId,empName,empSalary,address) VALUES (?,?,?,?,?);";
+
+    public static final String selectALL = "SELECT *  FROM testCassa.employees;";
+
+    public static final String selectSpecific =
+                    "SELECT *  FROM testCassa.employees WHERE empName= ?;";
+
+    public static final String updatePreparedQuery =
+                    "UPDATE testCassa.employees  SET vector_ts=?,address= ? WHERE empName= ?;";
+
+    public static final String deleteFromTable = " ";
+
+    public static final String deleteFromTablePrepared = " ";
+
+    // Set Values for Prepared Query
+
+    public static List<Object> setPreparedInsertValues1() {
+
+        List<Object> preppreparedInsertValues1 = new ArrayList<>();
+        String vectorTs =
+                        String.valueOf(Thread.currentThread().getId() + System.currentTimeMillis());
+        UUID empId = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40cd6");
+        BigInteger empSalary = BigInteger.valueOf(23443);
+        String empName = "Mr Test one";
+        preppreparedInsertValues1.add(vectorTs);
+        preppreparedInsertValues1.add(empId);
+        preppreparedInsertValues1.add(empName);
+        preppreparedInsertValues1.add(empSalary);
+        return preppreparedInsertValues1;
+    }
+
+    public static List<Object> setPreparedInsertValues2() {
+
+        List<Object> preparedInsertValues2 = new ArrayList<>();
+        String vectorTs =
+                        String.valueOf(Thread.currentThread().getId() + System.currentTimeMillis());
+        UUID empId = UUID.fromString("abc434cc-d657-4e90-b4e5-df4223d40cd6");
+        BigInteger empSalary = BigInteger.valueOf(45655);
+        String empName = "Mr Test two";
+        Map<String, String> address = new HashMap<>();
+        preparedInsertValues2.add(vectorTs);
+        preparedInsertValues2.add(empId);
+        preparedInsertValues2.add(empName);
+        preparedInsertValues2.add(empSalary);
+        address.put("Street", "1 some way");
+        address.put("City", "Some town");
+        preparedInsertValues2.add(address);
+        return preparedInsertValues2;
+    }
+
+    public static List<Object> setPreparedUpdateValues() {
+
+        List<Object> preparedUpdateValues = new ArrayList<>();
+        String vectorTs =
+                        String.valueOf(Thread.currentThread().getId() + System.currentTimeMillis());
+        Map<String, String> address = new HashMap<>();
+        preparedUpdateValues.add(vectorTs);
+        String empName = "Mr Test one";
+        address.put("Street", "101 Some Way");
+        address.put("City", "New York");
+        preparedUpdateValues.add(address);
+        preparedUpdateValues.add(empName);
+        return preparedUpdateValues;
+    }
+
+    // Generate Different Prepared Query Objects
+    /**
+     * Query Object for Get.
+     * 
+     * @return
+     */
+    public static PreparedQueryObject setPreparedGetQuery() {
+
+        PreparedQueryObject queryObject = new PreparedQueryObject();
+        String empName1 = "Mr Test one";
+        queryObject.appendQueryString(selectSpecific);
+        queryObject.addValue(empName1);
+        return queryObject;
+    }
+
+    /**
+     * Query Object 1 for Insert.
+     * 
+     * @return {@link PreparedQueryObject}
+     */
+    public static PreparedQueryObject setPreparedInsertQueryObject1() {
+
+        PreparedQueryObject queryobject = new PreparedQueryObject();
+        queryobject.appendQueryString(insertIntoTablePrepared1);
+        List<Object> values = setPreparedInsertValues1();
+        if (!values.isEmpty() || values != null) {
+            for (Object o : values) {
+                queryobject.addValue(o);
+            }
+        }
+        return queryobject;
+
+    }
+
+    /**
+     * Query Object 2 for Insert.
+     * 
+     * @return {@link PreparedQueryObject}
+     */
+    public static PreparedQueryObject setPreparedInsertQueryObject2() {
+
+        PreparedQueryObject queryobject = new PreparedQueryObject();
+        queryobject.appendQueryString(insertIntoTablePrepared2);
+        List<Object> values = setPreparedInsertValues2();
+        if (!values.isEmpty() || values != null) {
+            for (Object o : values) {
+                queryobject.addValue(o);
+            }
+        }
+        return queryobject;
+
+    }
+
+    /**
+     * Query Object for Update.
+     * 
+     * @return {@link PreparedQueryObject}
+     */
+    public static PreparedQueryObject setPreparedUpdateQueryObject() {
+
+        PreparedQueryObject queryobject = new PreparedQueryObject();
+        queryobject.appendQueryString(updatePreparedQuery);
+        List<Object> values = setPreparedUpdateValues();
+        if (!values.isEmpty() || values != null) {
+            for (Object o : values) {
+                queryobject.addValue(o);
+            }
+        }
+        return queryobject;
+
+    }
+
+    private static ArrayList<String> getAllPossibleLocalIps() {
+        ArrayList<String> allPossibleIps = new ArrayList<String>();
+        try {
+            Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces();
+            while (en.hasMoreElements()) {
+                NetworkInterface ni = (NetworkInterface) en.nextElement();
+                Enumeration<InetAddress> ee = ni.getInetAddresses();
+                while (ee.hasMoreElements()) {
+                    InetAddress ia = (InetAddress) ee.nextElement();
+                    allPossibleIps.add(ia.getHostAddress());
+                }
+            }
+        } catch (SocketException e) {
+            System.out.println(e.getMessage());
+        }
+        return allPossibleIps;
+    }
+
+    public static MusicDataStore connectToEmbeddedCassandra() {
+        Iterator<String> it = getAllPossibleLocalIps().iterator();
+        String address = "localhost";
+
+        Cluster cluster = null;
+        Session session = null;
+        while (it.hasNext()) {
+            try {
+
+                try {
+                    EmbeddedCassandraServerHelper.startEmbeddedCassandra(80000);
+                } catch (ConfigurationException | TTransportException | IOException e) {
+
+                    System.out.println(e.getMessage());
+                }
+
+                cluster = new Cluster.Builder().addContactPoint(address).withPort(9142).build();
+                cluster.getConfiguration().getSocketOptions().setReadTimeoutMillis(20000);
+                session = cluster.connect();
+
+                break;
+            } catch (NoHostAvailableException e) {
+                address = it.next();
+                System.out.println(e.getMessage());
+
+            }
+        }
+        return new MusicDataStore(cluster, session);
+
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/JsonResponseTest.java b/jar/src/test/java/org/onap/music/unittests/JsonResponseTest.java
new file mode 100644
index 00000000..9da10638
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/JsonResponseTest.java
@@ -0,0 +1,83 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.*;
+import java.util.Map;
+import org.junit.Test;
+import org.onap.music.main.ResultType;
+import org.onap.music.response.jsonobjects.JsonResponse;
+
+public class JsonResponseTest {
+
+    JsonResponse result = null;
+    
+    @Test
+    public void testJsonResponseBooleanStringString() {
+        result = new JsonResponse(ResultType.SUCCESS).setError("error").setMusicVersion("version");
+        assertEquals("error",result.getError());
+    }
+
+    @Test
+    public void testStatus() {
+        result = new JsonResponse(ResultType.SUCCESS);
+        result.setStatus(ResultType.SUCCESS);
+        assertEquals(ResultType.SUCCESS, result.getStatus());
+        result = new JsonResponse(ResultType.FAILURE).setError("error").setMusicVersion("version");
+        assertEquals(ResultType.FAILURE, result.getStatus());
+    }
+
+    @Test
+    public void testError() {
+        result = new JsonResponse(ResultType.FAILURE);
+        result.setError("error");
+        assertTrue(result.getError().equals("error"));
+        result.setError("");
+        assertFalse(result.getError().equals("error"));
+    }
+
+    @Test
+    public void testVersion() {
+        result = new JsonResponse(ResultType.SUCCESS);
+        result.setMusicVersion("version");
+        assertTrue(result.getMusicVersion().equals("version"));
+        result.setMusicVersion("");
+        assertFalse(result.getMusicVersion().equals("version"));
+    }
+
+    @Test
+    public void testToMap() {
+        result = new JsonResponse(ResultType.SUCCESS).setError("error").setMusicVersion("1.0");
+        Map<String,Object> myMap = result.toMap();
+        assertTrue(myMap.containsKey("status"));
+        assertEquals(ResultType.SUCCESS, myMap.get("status"));
+        assertEquals("error", myMap.get("error"));
+        assertEquals("1.0", myMap.get("version"));
+        
+        result = new JsonResponse(ResultType.FAILURE);
+        myMap = result.toMap();
+        assertTrue(myMap.containsKey("status"));
+        assertEquals(ResultType.FAILURE, myMap.get("status"));
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/MusicDataStoreTest.java b/jar/src/test/java/org/onap/music/unittests/MusicDataStoreTest.java
new file mode 100644
index 00000000..16d2af02
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/MusicDataStoreTest.java
@@ -0,0 +1,162 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+import org.mockito.Mock;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+
+import org.onap.music.datastore.MusicDataStore;
+import org.onap.music.datastore.PreparedQueryObject;
+
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.datastax.driver.core.TableMetadata;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class MusicDataStoreTest {
+
+    static MusicDataStore dataStore;
+    static PreparedQueryObject testObject;
+
+    @BeforeClass
+    public static void init() {
+        dataStore = CassandraCQL.connectToEmbeddedCassandra();
+
+    }
+
+    @AfterClass
+    public static void close() throws MusicServiceException, MusicQueryException {
+ 
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.dropKeyspace);
+        dataStore.executePut(testObject, "eventual");
+        dataStore.close();
+
+    }
+
+    @Test
+    public void Test1_SetUp() throws MusicServiceException, MusicQueryException {
+        boolean result = false;
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.createKeySpace);
+        result = dataStore.executePut(testObject, "eventual");;
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.createTableEmployees);
+        result = dataStore.executePut(testObject, "eventual");
+        assertEquals(true, result);
+
+    }
+
+    @Test
+    public void Test2_ExecutePut_eventual_insert() throws MusicServiceException, MusicQueryException {
+        testObject = CassandraCQL.setPreparedInsertQueryObject1();
+        boolean result = dataStore.executePut(testObject, "eventual");
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test3_ExecutePut_critical_insert() throws MusicServiceException, MusicQueryException {
+        testObject = CassandraCQL.setPreparedInsertQueryObject2();
+        boolean result = dataStore.executePut(testObject, "Critical");
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test4_ExecutePut_eventual_update() throws MusicServiceException, MusicQueryException {
+        testObject = CassandraCQL.setPreparedUpdateQueryObject();
+        boolean result = false;
+        result = dataStore.executePut(testObject, "eventual");
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test5_ExecuteEventualGet() throws MusicServiceException, MusicQueryException {
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.selectALL);
+        boolean result = false;
+        int count = 0;
+        ResultSet output = null;
+        output = dataStore.executeEventualGet(testObject);
+        System.out.println(output);
+        ;
+        for (Row row : output) {
+            count++;
+            System.out.println(row.toString());
+        }
+        if (count == 2) {
+            result = true;
+        }
+        assertEquals(true, result);
+    }
+
+    @Test
+    public void Test6_ExecuteCriticalGet() throws MusicServiceException, MusicQueryException {
+        testObject = CassandraCQL.setPreparedGetQuery();
+        boolean result = false;
+        int count = 0;
+        ResultSet output = null;
+        output = dataStore.executeCriticalGet(testObject);
+        System.out.println(output);
+        ;
+        for (Row row : output) {
+            count++;
+            System.out.println(row.toString());
+        }
+        if (count == 1) {
+            result = true;
+        }
+        assertEquals(true, result);
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void Test7_exception() {
+        PreparedQueryObject queryObject = null;
+        try {
+            dataStore.executePut(queryObject, "critical");
+        } catch (MusicQueryException | MusicServiceException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+    
+    @Test
+    public void Test8_columnDataType() {
+        DataType data = dataStore.returnColumnDataType("testCassa", "employees", "empName");
+        String datatype = data.toString();
+        assertEquals("text",datatype);
+    }
+    
+    @Test
+    public void Test8_columnMetdaData() {
+        TableMetadata data = dataStore.returnColumnMetadata("testCassa", "employees");
+        assertNotNull(data);
+    }
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/MusicUtilTest.java b/jar/src/test/java/org/onap/music/unittests/MusicUtilTest.java
new file mode 100644
index 00000000..b117c330
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/MusicUtilTest.java
@@ -0,0 +1,207 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.*;
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.cassandra.exceptions.PreparedQueryNotFoundException;
+import org.junit.Test;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.main.MusicUtil;
+import com.datastax.driver.core.DataType;
+import javassist.CodeConverter.ArrayAccessReplacementMethodNames;
+
+public class MusicUtilTest {
+
+    @Test
+    public void testGetCassName() {
+        MusicUtil.setCassName("Cassandra");
+        assertTrue(MusicUtil.getCassName().equals("Cassandra"));
+    }
+
+    @Test
+    public void testGetCassPwd() {
+        MusicUtil.setCassPwd("Cassandra");
+        assertTrue(MusicUtil.getCassPwd().equals("Cassandra"));
+    }
+
+    @Test
+    public void testGetAafEndpointUrl() {
+        MusicUtil.setAafEndpointUrl("url");
+        assertEquals(MusicUtil.getAafEndpointUrl(),"url");
+    }
+
+    @Test
+    public void testGetMyId() {
+        MusicUtil.setMyId(1);
+        assertEquals(MusicUtil.getMyId(),1);
+    }
+
+    @Test
+    public void testGetAllIds() {
+        List<String> ids = new ArrayList<String>();
+        ids.add("1");
+        ids.add("2");
+        ids.add("3");
+        MusicUtil.setAllIds(ids);
+        assertEquals(MusicUtil.getAllIds().get(0),"1");
+    }
+
+//    @Test
+//    public void testGetPublicIp() {
+//        MusicUtil.setPublicIp("10.0.0.1");
+//        assertEquals(MusicUtil.getPublicIp(),"10.0.0.1");
+//    }
+
+    @Test
+    public void testGetAllPublicIps() {
+        List<String> ips = new ArrayList<String>();
+        ips.add("10.0.0.1");
+        ips.add("10.0.0.2");
+        ips.add("10.0.0.3");
+        MusicUtil.setAllPublicIps(ips);
+        assertEquals(MusicUtil.getAllPublicIps().get(1),"10.0.0.2");
+    }
+
+    @Test
+    public void testGetPropkeys() {
+        assertEquals(MusicUtil.getPropkeys()[2],"music.ip");
+    }
+
+    @Test
+    public void testGetMusicRestIp() {
+        MusicUtil.setMusicRestIp("localhost");
+        assertEquals(MusicUtil.getMusicRestIp(),"localhost");
+    }
+
+    @Test
+    public void testGetMusicPropertiesFilePath() {
+        MusicUtil.setMusicPropertiesFilePath("filepath");
+        assertEquals(MusicUtil.getMusicPropertiesFilePath(),"filepath");
+    }
+
+    @Test
+    public void testGetDefaultLockLeasePeriod() {
+        MusicUtil.setDefaultLockLeasePeriod(5000);
+        assertEquals(MusicUtil.getDefaultLockLeasePeriod(),5000);
+    }
+
+    @Test
+    public void testIsDebug() {
+        MusicUtil.setDebug(true);
+        assertTrue(MusicUtil.isDebug());
+    }
+
+    @Test
+    public void testGetVersion() {
+        MusicUtil.setVersion("1.0.0");
+        assertEquals(MusicUtil.getVersion(),"1.0.0");
+    }
+
+    /*@Test
+    public void testGetMyZkHost() {
+        MusicUtil.setMyZkHost("10.0.0.2");
+        assertEquals(MusicUtil.getMyZkHost(),"10.0.0.2");
+    }*/
+
+    @Test
+    public void testGetMyCassaHost() {
+        MusicUtil.setMyCassaHost("10.0.0.2");
+        assertEquals(MusicUtil.getMyCassaHost(),"10.0.0.2");
+    }
+
+    @Test
+    public void testGetDefaultMusicIp() {
+        MusicUtil.setDefaultMusicIp("10.0.0.2");
+        assertEquals(MusicUtil.getDefaultMusicIp(),"10.0.0.2");
+    }
+
+//    @Test
+//    public void testGetTestType() {
+//      fail("Not yet implemented"); // TODO
+//    }
+
+    @Test
+    public void testIsValidQueryObject() {
+        PreparedQueryObject myQueryObject = new PreparedQueryObject();
+        myQueryObject.appendQueryString("select * from apple where type = ?");
+        myQueryObject.addValue("macintosh");
+        assertTrue(MusicUtil.isValidQueryObject(true,myQueryObject));
+
+        myQueryObject.appendQueryString("select * from apple");
+        assertTrue(MusicUtil.isValidQueryObject(false,myQueryObject));
+
+        myQueryObject.appendQueryString("select * from apple where type = ?");
+        assertFalse(MusicUtil.isValidQueryObject(true,myQueryObject));
+
+        myQueryObject = new PreparedQueryObject();
+        myQueryObject.appendQueryString("");
+        System.out.println("#######" + myQueryObject.getQuery().isEmpty());
+        assertFalse(MusicUtil.isValidQueryObject(false,myQueryObject));
+
+    
+    }
+
+    @Test
+    public void testConvertToCQLDataType() throws Exception {
+        Map<String,Object> myMap = new HashMap<String,Object>();
+        myMap.put("name","tom");
+        assertEquals(MusicUtil.convertToCQLDataType(DataType.varchar(),"Happy People"),"'Happy People'");
+        assertEquals(MusicUtil.convertToCQLDataType(DataType.uuid(),UUID.fromString("29dc2afa-c2c0-47ae-afae-e72a645308ab")),"29dc2afa-c2c0-47ae-afae-e72a645308ab");
+        assertEquals(MusicUtil.convertToCQLDataType(DataType.blob(),"Hi"),"Hi");
+        assertEquals(MusicUtil.convertToCQLDataType(DataType.map(DataType.varchar(),DataType.varchar()),myMap),"{'name':'tom'}");
+    }
+
+    @Test
+    public void testConvertToActualDataType() throws Exception {
+        assertEquals(MusicUtil.convertToActualDataType(DataType.varchar(),"Happy People"),"Happy People");
+        assertEquals(MusicUtil.convertToActualDataType(DataType.uuid(),"29dc2afa-c2c0-47ae-afae-e72a645308ab"),UUID.fromString("29dc2afa-c2c0-47ae-afae-e72a645308ab"));
+        assertEquals(MusicUtil.convertToActualDataType(DataType.varint(),"1234"),BigInteger.valueOf(Long.parseLong("1234")));
+        assertEquals(MusicUtil.convertToActualDataType(DataType.bigint(),"123"),Long.parseLong("123"));
+        assertEquals(MusicUtil.convertToActualDataType(DataType.cint(),"123"),Integer.parseInt("123"));
+        assertEquals(MusicUtil.convertToActualDataType(DataType.cfloat(),"123.01"),Float.parseFloat("123.01"));
+        assertEquals(MusicUtil.convertToActualDataType(DataType.cdouble(),"123.02"),Double.parseDouble("123.02"));
+        assertEquals(MusicUtil.convertToActualDataType(DataType.cboolean(),"true"),Boolean.parseBoolean("true"));
+        Map<String,Object> myMap = new HashMap<String,Object>();
+        myMap.put("name","tom");
+        assertEquals(MusicUtil.convertToActualDataType(DataType.map(DataType.varchar(),DataType.varchar()),myMap),myMap);
+
+    }
+
+    @Test
+    public void testJsonMaptoSqlString() throws Exception {
+        Map<String,Object> myMap = new HashMap<>();
+        myMap.put("name","tom");
+        myMap.put("value",5);
+        String result = MusicUtil.jsonMaptoSqlString(myMap,",");
+        assertTrue(result.contains("name"));
+        assertTrue(result.contains("value"));
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/ResultTypeTest.java b/jar/src/test/java/org/onap/music/unittests/ResultTypeTest.java
new file mode 100644
index 00000000..012629e0
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/ResultTypeTest.java
@@ -0,0 +1,43 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.*;
+import org.junit.Test;
+import org.onap.music.main.ResultType;
+
+public class ResultTypeTest {
+
+    @Test
+    public void testResultType() {
+        assertEquals("SUCCESS",ResultType.SUCCESS.name());
+        assertEquals("FAILURE",ResultType.FAILURE.name());
+    }
+
+    @Test
+    public void testGetResult() {
+        assertEquals("Success",ResultType.SUCCESS.getResult());
+        assertEquals("Failure",ResultType.FAILURE.getResult());
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/ReturnTypeTest.java b/jar/src/test/java/org/onap/music/unittests/ReturnTypeTest.java
new file mode 100644
index 00000000..c22b0155
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/ReturnTypeTest.java
@@ -0,0 +1,83 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.*;
+import java.util.Map;
+import org.apache.tools.ant.filters.TokenFilter.ContainsString;
+import org.hamcrest.core.AnyOf;
+import org.junit.Test;
+import org.onap.music.main.ResultType;
+import org.onap.music.main.ReturnType;
+
+public class ReturnTypeTest {
+
+    @Test
+    public void testReturnType() {
+        ReturnType result = new ReturnType(ResultType.SUCCESS,"message");
+        assertEquals(result.getMessage(),"message");
+        assertEquals(result.getResult(),ResultType.SUCCESS);
+    }
+
+    @Test
+    public void testTimingInfo() {
+        ReturnType result = new ReturnType(ResultType.SUCCESS,"message");
+        result.setTimingInfo("123");
+        assertEquals(result.getTimingInfo(),"123");
+    }
+
+    @Test
+    public void testGetResult() {
+        ReturnType result = new ReturnType(ResultType.FAILURE,"message");
+        assertEquals(result.getResult(),ResultType.FAILURE);
+    }
+
+    @Test
+    public void testGetMessage() {
+        ReturnType result = new ReturnType(ResultType.SUCCESS,"message");
+        result.setMessage("NewMessage");
+        assertEquals(result.getMessage(),"NewMessage");
+    }
+
+    @Test
+    public void testToJson() {
+        ReturnType result = new ReturnType(ResultType.SUCCESS,"message");
+        String myJson = result.toJson();
+        assertTrue(myJson.contains("message"));
+    }
+
+    @Test
+    public void testToString() {
+        ReturnType result = new ReturnType(ResultType.SUCCESS,"message");
+        String test = result.toString();
+        assertTrue(test.contains("message"));
+    }
+
+    @Test
+    public void testToMap() {
+        ReturnType result = new ReturnType(ResultType.SUCCESS,"message");
+        Map<String, Object> myMap = result.toMap();
+        assertTrue(myMap.containsKey("message"));
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/TestLockStore.java b/jar/src/test/java/org/onap/music/unittests/TestLockStore.java
new file mode 100644
index 00000000..4dbc7b4f
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/TestLockStore.java
@@ -0,0 +1,53 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+import org.apache.log4j.Logger;
+import org.onap.music.lockingservice.MusicLockingService;
+
+public class TestLockStore {
+    final static Logger logger = Logger.getLogger(TestLockStore.class);
+
+    public static void main(String[] args) throws Exception {
+        String lockName = "/achristmkllas";
+        MusicLockingService ml = new MusicLockingService();
+        ml.deleteLock(lockName);
+
+
+        logger.info("lockname:" + lockName);
+
+        String lockId1 = ml.createLockId(lockName);
+        logger.info("lockId1 " + lockId1);
+        logger.info(ml.isMyTurn(lockId1));
+
+        String lockId2 = ml.createLockId(lockName);
+        logger.info("lockId2 " + lockId2);
+        logger.info("check " + ml.isMyTurn("$bank$x-94608776321630264-0000000000"));
+        logger.info(ml.isMyTurn(lockId2));
+
+        // zkClient.unlock(lockId1);
+        // logger.info(ml.lock(lockId2));
+        // zkClient.unlock(lockId2);
+    }
+
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/TestMusicCore.java b/jar/src/test/java/org/onap/music/unittests/TestMusicCore.java
new file mode 100644
index 00000000..e798aaf1
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/TestMusicCore.java
@@ -0,0 +1,489 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.*;
+import static org.onap.music.main.MusicCore.mDstoreHandle;
+import static org.onap.music.main.MusicCore.mLockHandle;
+
+import org.apache.zookeeper.KeeperException.NoNodeException;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.music.exceptions.MusicLockingException;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.lockingservice.MusicLockState;
+import org.onap.music.lockingservice.MusicLockingService;
+import org.onap.music.lockingservice.MusicLockState.LockStatus;
+import org.onap.music.main.MusicCore;
+import org.onap.music.main.MusicUtil;
+import org.onap.music.main.ResultType;
+import org.onap.music.main.ReturnType;
+import org.onap.music.main.MusicCore.Condition;
+import org.onap.music.datastore.MusicDataStore;
+import org.onap.music.datastore.PreparedQueryObject;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Session;
+
+@RunWith(MockitoJUnitRunner.class)
+public class TestMusicCore {
+
+    @Mock
+    private Condition condition;
+
+    @Mock
+    private ResultSet rs;
+
+    @Mock
+    private PreparedQueryObject preparedQueryObject;
+    
+    @Mock
+    private Session session;
+
+    @Before
+    public void setUp() {
+        mLockHandle = Mockito.mock(MusicLockingService.class);
+
+    }
+
+    @Test
+    public void testCreateLockReferenceforvalidlock() {
+        Mockito.when(mLockHandle.createLockId("/" + "test")).thenReturn("lock");
+        String lockId = MusicCore.createLockReference("test");
+        assertEquals("lock", lockId);
+        Mockito.verify(mLockHandle).createLockId("/" + "test");
+    }
+
+    @Test
+    public void testIsTableOrKeySpaceLock() {
+        Boolean result = MusicCore.isTableOrKeySpaceLock("ks1.tn1");
+        assertTrue(result);
+    }
+
+    @Test
+    public void testIsTableOrKeySpaceLockwithPrimarykey() {
+        Boolean result = MusicCore.isTableOrKeySpaceLock("ks1.tn1.pk1");
+        assertFalse(result);
+    }
+
+    @Test
+    public void testGetMusicLockState() throws MusicLockingException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
+        Mockito.when(mLockHandle.getLockState("ks1.tb1.pk1")).thenReturn(musicLockState);
+        MusicLockState mls = MusicCore.getMusicLockState("ks1.tb1.pk1");
+        assertEquals(musicLockState, mls);
+        Mockito.verify(mLockHandle).getLockState("ks1.tb1.pk1");
+    }
+
+    @Test
+    public void testAcquireLockifisMyTurnTrue() throws MusicLockingException {
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        ReturnType lock = MusicCore.acquireLock("ks1.tn1", "id1");
+        assertEquals(lock.getResult(), ResultType.SUCCESS);
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+    }
+
+    @Test
+    public void testAcquireLockifisMyTurnFalse() throws MusicLockingException {
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
+        ReturnType lock = MusicCore.acquireLock("ks1.ts1", "id1");
+        assertEquals(lock.getResult(), ResultType.FAILURE);
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+    }
+
+    @Test
+    public void testAcquireLockifisMyTurnTrueandIsTableOrKeySpaceLockTrue() throws MusicLockingException {
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        ReturnType lock = MusicCore.acquireLock("ks1.tn1", "id1");
+        assertEquals(lock.getResult(), ResultType.SUCCESS);
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+    }
+
+    @Test
+    public void testAcquireLockifisMyTurnTrueandIsTableOrKeySpaceLockFalseandHaveLock() throws MusicLockingException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        ReturnType lock = MusicCore.acquireLock("ks1.tn1.pk1", "id1");
+        assertEquals(lock.getResult(), ResultType.SUCCESS);
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle).getLockState("ks1.tn1.pk1");
+    }
+
+    @Test
+    public void testAcquireLockifisMyTurnTrueandIsTableOrKeySpaceLockFalseandDontHaveLock() throws MusicLockingException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id2");
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        ReturnType lock = MusicCore.acquireLock("ks1.tn1.pk1", "id1");
+        assertEquals(lock.getResult(), ResultType.SUCCESS);
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle).getLockState("ks1.tn1.pk1");
+    }
+    
+    @Test
+    public void testAcquireLockifLockRefDoesntExist() throws MusicLockingException {
+        Mockito.when(mLockHandle.lockIdExists("bs1")).thenReturn(false);
+        ReturnType lock = MusicCore.acquireLock("ks1.ts1", "bs1");
+        assertEquals(lock.getResult(), ResultType.FAILURE);
+        assertEquals(lock.getMessage(), "Lockid doesn't exist");
+        Mockito.verify(mLockHandle).lockIdExists("bs1");
+    }
+    
+    @Test
+    public void testAcquireLockWithLeasewithLease() throws MusicLockingException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
+        musicLockState.setLeasePeriod(0);
+        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
+        assertEquals(expectedResult.getResult(), actualResult.getResult());
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
+    }
+    
+    @Test
+    public void testAcquireLockWithLeasewithException() throws MusicLockingException {
+        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "failure");
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenThrow(new MusicLockingException());
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
+        assertEquals(expectedResult.getResult(), actualResult.getResult());
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
+    }
+
+    @Test
+    public void testAcquireLockWithLeasewithLockStatusLOCKED() throws MusicLockingException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
+        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
+        assertEquals(expectedResult.getResult(), actualResult.getResult());
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
+    }
+
+    @Test
+    public void testAcquireLockWithLeasewithLockStatusUNLOCKED() throws MusicLockingException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
+        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
+        assertEquals(expectedResult.getResult(), actualResult.getResult());
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
+
+    }
+
+    @Test
+    public void testAcquireLockWithLeaseIfNotMyTurn() throws MusicLockingException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
+        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
+        ReturnType actualResult = MusicCore.acquireLockWithLease("ks1.tn1.pk1", "id1", 6000);
+        assertEquals(expectedResult.getResult(), actualResult.getResult());
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle).getLockState("ks1.tn1.pk1");
+    }
+
+    @Test
+    public void testQuorumGet() throws MusicServiceException, MusicQueryException {
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        rs = Mockito.mock(ResultSet.class);
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
+        ResultSet rs1 = MusicCore.quorumGet(preparedQueryObject);
+        assertNotNull(rs1);
+    }
+
+    @Test
+    public void testGetLockNameFromId() {
+        String lockname = MusicCore.getLockNameFromId("lockName$id");
+        assertEquals("lockName", lockname);
+    }
+
+    @Test
+    public void testDestroyLockRef() throws NoNodeException {
+        Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
+        MusicCore.destroyLockRef("id1");
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
+    }
+
+    @Test
+    public void testreleaseLockwithvoluntaryReleaseTrue() throws NoNodeException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
+        Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
+        MusicLockState musicLockState1 = MusicCore.releaseLock("id1", true);
+        assertEquals(musicLockState.getLockStatus(), musicLockState1.getLockStatus());
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
+    }
+
+    @Test
+    public void testreleaseLockwithvoluntaryReleaseFalse() throws NoNodeException {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
+        Mockito.doNothing().when(mLockHandle).unlockAndDeleteId("id1");
+        MusicLockState musicLockState1 = MusicCore.releaseLock("id1", false);
+        assertEquals(musicLockState.getLockStatus(), musicLockState1.getLockStatus());
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).unlockAndDeleteId("id1");
+    }
+
+    @Test
+    public void testDeleteLock() throws MusicLockingException {
+        Mockito.doNothing().when(mLockHandle).deleteLock("/" + "id1");
+        MusicCore.deleteLock("id1");
+        Mockito.verify(mLockHandle).deleteLock("/" + "id1");
+    }
+
+    /*
+     * @Test public void testNonKeyRelatedPut() throws Exception { mDstoreHandle =
+     * Mockito.mock(MusicDataStore.class); Mockito.when(mDstoreHandle.executePut("qu1",
+     * "consistency")).thenReturn(true); Boolean result = MusicCore.nonKeyRelatedPut("qu1",
+     * "consistency"); assertTrue(result); Mockito.verify(mDstoreHandle).executePut("qu1",
+     * "consistency"); }
+     */
+
+    @Test
+    public void testEventualPutPreparedQuery() throws MusicServiceException, MusicQueryException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "eventual")).thenReturn(true);
+        ReturnType actualResult = MusicCore.eventualPut(preparedQueryObject);
+        assertEquals(expectedResult.getResult(), actualResult.getResult());
+        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "eventual");
+    }
+
+    @Test
+    public void testEventualPutPreparedQuerywithResultFalse()
+                    throws MusicServiceException, MusicQueryException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "eventual")).thenReturn(false);
+        ReturnType actualResult = MusicCore.eventualPut(preparedQueryObject);
+        assertEquals(expectedResult.getResult(), actualResult.getResult());
+        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "eventual");
+        //Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, MusicUtil.EVENTUAL);
+    }
+
+    @Test
+    public void testCriticalPutPreparedQuerywithValidLockId()
+                    throws Exception {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
+        Mockito.when(condition.testCondition()).thenReturn(true);
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
+        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
+                        .thenReturn(musicLockState);
+        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "critical")).thenReturn(true);
+        ReturnType returnType = MusicCore.criticalPut("ks1", "tn1", "pk1", preparedQueryObject,
+                        "id1", condition);
+        assertEquals(expectedResult.getResult(), returnType.getResult());
+        Mockito.verify(condition).testCondition();
+        Mockito.verify(mLockHandle).getLockState("ks1" + "." + "tn1" + "." + "pk1");
+        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "critical");
+    }
+
+    @Test
+    public void testCriticalPutPreparedQuerywithInvalidLockId() throws MusicLockingException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
+        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
+        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
+                        .thenReturn(musicLockState);
+        ReturnType returnType = MusicCore.criticalPut("ks1", "tn1", "pk1", preparedQueryObject,
+                        "id1", condition);
+        assertEquals(expectedResult.getResult(), returnType.getResult());
+        Mockito.verify(mLockHandle).getLockState("ks1" + "." + "tn1" + "." + "pk1");
+    }
+
+    @Test
+    public void testCriticalPutPreparedQuerywithvalidLockIdandTestConditionFalse() throws Exception {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
+        Mockito.when(condition.testCondition()).thenReturn(false);
+        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
+        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
+                        .thenReturn(musicLockState);
+        ReturnType returnType = MusicCore.criticalPut("ks1", "tn1", "pk1", preparedQueryObject,
+                        "id1", condition);
+        assertEquals(expectedResult.getResult(), returnType.getResult());
+        Mockito.verify(condition).testCondition();
+        Mockito.verify(mLockHandle).getLockState("ks1" + "." + "tn1" + "." + "pk1");
+    }
+
+    @Test
+    public void testNonKeyRelatedPutPreparedQuery() throws Exception {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "consistency")).thenReturn(true);
+        ResultType result = MusicCore.nonKeyRelatedPut(preparedQueryObject, "consistency");
+        assertEquals(ResultType.SUCCESS, result);
+        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "consistency");
+    }
+
+    @Test
+    public void testAtomicPutPreparedQuery() throws Exception {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
+        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
+        ReturnType expectedResult = new ReturnType(ResultType.SUCCESS, "Succes");
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        Mockito.when(condition.testCondition()).thenReturn(true);
+        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
+                        .thenReturn(musicLockState);
+        Mockito.when(mDstoreHandle.executePut(preparedQueryObject, "critical")).thenReturn(true);
+        ReturnType returnType =
+                        MusicCore.atomicPut("ks1", "tn1", "pk1", preparedQueryObject, condition);
+        assertEquals(expectedResult.getResult(), returnType.getResult());
+        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(condition).testCondition();
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
+                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
+        Mockito.verify(mDstoreHandle).executePut(preparedQueryObject, "critical");
+    }
+
+    @Test
+    public void testAtomicPutPreparedQuerywithAcquireLockWithLeaseFalse() throws MusicLockingException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
+        ReturnType expectedResult = new ReturnType(ResultType.FAILURE, "Failure");
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
+        ReturnType returnType =
+                        MusicCore.atomicPut("ks1", "tn1", "pk1", preparedQueryObject, condition);
+        assertEquals(expectedResult.getResult(), returnType.getResult());
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
+    }
+
+    @Test
+    public void testAtomicGetPreparedQuery() throws MusicServiceException, MusicQueryException, MusicLockingException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        rs = Mockito.mock(ResultSet.class);
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
+        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
+        Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
+        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
+                        .thenReturn(musicLockState);
+        Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
+        ResultSet rs1 = MusicCore.atomicGet("ks1", "tn1", "pk1", preparedQueryObject);
+        assertNotNull(rs1);
+        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce()).getLockState("ks1.tn1.pk1");
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
+                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
+        Mockito.verify(mDstoreHandle).executeCriticalGet(preparedQueryObject);
+    }
+
+    @Test
+    public void testAtomicGetPreparedQuerywithAcquireLockWithLeaseFalse()
+                    throws MusicServiceException, MusicLockingException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        rs = Mockito.mock(ResultSet.class);
+        Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
+        Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
+        ResultSet rs1 = MusicCore.atomicGet("ks1", "tn1", "pk1", preparedQueryObject);
+        assertNull(rs1);
+        Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
+        Mockito.verify(mLockHandle).isMyTurn("id1");
+    }
+
+    @Test
+    public void testGetPreparedQuery() throws MusicServiceException, MusicQueryException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        rs = Mockito.mock(ResultSet.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mDstoreHandle.executeEventualGet(preparedQueryObject)).thenReturn(rs);
+        ResultSet rs1 = MusicCore.get(preparedQueryObject);
+        assertNotNull(rs1);
+        Mockito.verify(mDstoreHandle).executeEventualGet(preparedQueryObject);
+
+    }
+
+    @Test
+    public void testcriticalGetPreparedQuery() throws MusicServiceException, MusicQueryException, MusicLockingException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id1");
+        rs = Mockito.mock(ResultSet.class);
+        session = Mockito.mock(Session.class);
+        Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
+                        .thenReturn(musicLockState);
+        Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
+        ResultSet rs1 = MusicCore.criticalGet("ks1", "tn1", "pk1", preparedQueryObject, "id1");
+        assertNotNull(rs1);
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
+                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
+        Mockito.verify(mDstoreHandle).executeCriticalGet(preparedQueryObject);
+    }
+
+    @Test
+    public void testcriticalGetPreparedQuerywithInvalidLockId() throws MusicServiceException, MusicLockingException {
+        mDstoreHandle = Mockito.mock(MusicDataStore.class);
+        preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+        MusicLockState musicLockState = new MusicLockState(LockStatus.UNLOCKED, "id2");
+        Mockito.when(mLockHandle.getLockState("ks1" + "." + "tn1" + "." + "pk1"))
+                        .thenReturn(musicLockState);
+        ResultSet rs1 = MusicCore.criticalGet("ks1", "tn1", "pk1", preparedQueryObject, "id1");
+        assertNull(rs1);
+        Mockito.verify(mLockHandle, Mockito.atLeastOnce())
+                        .getLockState("ks1" + "." + "tn1" + "." + "pk1");
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/TestMusicCoreIntegration.java b/jar/src/test/java/org/onap/music/unittests/TestMusicCoreIntegration.java
new file mode 100644
index 00000000..d327d0f0
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/TestMusicCoreIntegration.java
@@ -0,0 +1,176 @@
+/*
+ * ============LICENSE_START========================================== org.onap.music
+ * =================================================================== Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import java.io.File;
+import java.util.List;
+import org.apache.curator.test.TestingServer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runners.MethodSorters;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.exceptions.MusicQueryException;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.lockingservice.MusicLockState;
+import org.onap.music.lockingservice.MusicLockingService;
+import org.onap.music.lockingservice.MusicLockState.LockStatus;
+import org.onap.music.main.MusicCore;
+import org.onap.music.main.MusicUtil;
+import org.onap.music.main.ResultType;
+import org.onap.music.main.ReturnType;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestMusicCoreIntegration {
+
+    static TestingServer zkServer;
+    static PreparedQueryObject testObject;
+    static String lockId = null;
+    static String lockName = "ks1.tb1.pk1";
+
+    @BeforeClass
+    public static void init() throws Exception {
+        try {
+            MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
+            zkServer = new TestingServer(2181, new File("/tmp/zk"));
+            MusicCore.mLockHandle = new MusicLockingService();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        System.out.println("####Port:" + zkServer.getPort());
+    }
+
+    @AfterClass
+    public static void tearDownAfterClass() throws Exception {
+        System.out.println("After class");
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.dropKeyspace);
+        MusicCore.eventualPut(testObject);
+        MusicCore.deleteLock(lockName);
+        MusicCore.mDstoreHandle.close();
+        MusicCore.mLockHandle.getzkLockHandle().close();
+        MusicCore.mLockHandle.close();
+        zkServer.stop();
+
+    }
+
+    @Test
+    public void Test1_SetUp() throws MusicServiceException, MusicQueryException {
+        MusicCore.mLockHandle = new MusicLockingService();
+        ResultType result = ResultType.FAILURE;
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.createKeySpace);
+        MusicCore.eventualPut(testObject);
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(CassandraCQL.createTableEmployees);
+        result = MusicCore.nonKeyRelatedPut(testObject, MusicUtil.EVENTUAL);
+        assertEquals(ResultType.SUCCESS, result);
+    }
+
+    @Test
+    public void Test2_atomicPut() throws Exception {
+        testObject = new PreparedQueryObject();
+        testObject = CassandraCQL.setPreparedInsertQueryObject1();
+        ReturnType returnType = MusicCore.atomicPut("testCassa", "employees", "Mr Test one",
+                        testObject, null);
+        assertEquals(ResultType.SUCCESS, returnType.getResult());
+    }
+
+    @Test
+    public void Test3_atomicPutWithDeleteLock() throws Exception {
+        testObject = new PreparedQueryObject();
+        testObject = CassandraCQL.setPreparedInsertQueryObject2();
+        ReturnType returnType = MusicCore.atomicPutWithDeleteLock("testCassa", "employees",
+                        "Mr Test two", testObject, null);
+        assertEquals(ResultType.SUCCESS, returnType.getResult());
+    }
+
+    @Test
+    public void Test4_atomicGetWithDeleteLock() throws Exception {
+        testObject = new PreparedQueryObject();
+        testObject = CassandraCQL.setPreparedGetQuery();
+        ResultSet resultSet = MusicCore.atomicGetWithDeleteLock("testCassa", "employees",
+                        "Mr Test one", testObject);
+        List<Row> rows = resultSet.all();
+        assertEquals(1, rows.size());
+    }
+
+    @Test
+    public void Test5_atomicGet() throws Exception {
+        testObject = new PreparedQueryObject();
+        testObject = CassandraCQL.setPreparedGetQuery();
+        ResultSet resultSet =
+                        MusicCore.atomicGet("testCassa", "employees", "Mr Test two", testObject);
+        List<Row> rows = resultSet.all();
+        assertEquals(1, rows.size());
+    }
+
+    @Test
+    public void Test6_createLockReference() throws Exception {
+        lockId = MusicCore.createLockReference(lockName);
+        assertNotNull(lockId);
+    }
+
+    @Test
+    public void Test7_acquireLockwithLease() throws Exception {
+        ReturnType lockLeaseStatus = MusicCore.acquireLockWithLease(lockName, lockId, 1000);
+        assertEquals(ResultType.SUCCESS, lockLeaseStatus.getResult());
+    }
+
+    @Test
+    public void Test8_acquireLock() throws Exception {
+        ReturnType lockStatus = MusicCore.acquireLock(lockName, lockId);
+        assertEquals(ResultType.SUCCESS, lockStatus.getResult());
+    }
+
+    @Test
+    public void Test9_release() throws Exception {
+        MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id1");
+        MusicLockState musicLockState1 = new MusicLockState(LockStatus.UNLOCKED, "id1");
+        MusicCore.whoseTurnIsIt(lockName);
+        MusicLockState mls = MusicCore.getMusicLockState(lockName);
+        boolean voluntaryRelease = true;
+        MusicLockState mls1 = MusicCore.releaseLock(lockId, voluntaryRelease);
+        assertEquals(musicLockState.getLockStatus(), mls.getLockStatus());
+        assertEquals(musicLockState1.getLockStatus(), mls1.getLockStatus());
+    }
+
+    @Test
+    public void Test10_create() {
+        MusicCore.pureZkCreate("/nodeName");
+    }
+
+    @Test
+    public void Test11_write() {
+        MusicCore.pureZkWrite("nodeName", "I'm Test".getBytes());
+    }
+
+    @Test
+    public void Test12_read() {
+        byte[] data = MusicCore.pureZkRead("nodeName");
+        String data1 = new String(data);
+        assertEquals("I'm Test", data1);
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/TestRestMusicData.java b/jar/src/test/java/org/onap/music/unittests/TestRestMusicData.java
new file mode 100644
index 00000000..febf6c76
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/TestRestMusicData.java
@@ -0,0 +1,718 @@
+/*
+ * ============LICENSE_START========================================== org.onap.music
+ * =================================================================== Copyright (c) 2017 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.unittests;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import org.apache.curator.test.TestingServer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mindrot.jbcrypt.BCrypt;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+import org.onap.music.datastore.jsonobjects.JsonOnboard;
+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.lockingservice.MusicLockingService;
+import org.onap.music.main.MusicCore;
+import org.onap.music.main.MusicUtil;
+import org.onap.music.main.ResultType;
+import org.onap.music.rest.RestMusicAdminAPI;
+import org.onap.music.rest.RestMusicDataAPI;
+import org.onap.music.rest.RestMusicLocksAPI;
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.sun.jersey.core.util.MultivaluedMapImpl;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@RunWith(MockitoJUnitRunner.class)
+public class TestRestMusicData {
+
+    RestMusicDataAPI data = new RestMusicDataAPI();
+    RestMusicAdminAPI admin = new RestMusicAdminAPI();
+    RestMusicLocksAPI lock = new RestMusicLocksAPI(); 
+    static PreparedQueryObject testObject;
+    static TestingServer zkServer;
+
+    @Mock
+    HttpServletResponse http;
+
+    @Mock
+    UriInfo info;
+
+    static String appName = "TestApp";
+    static String userId = "TestUser";
+    static String password = "TestPassword";
+    static boolean isAAF = false;
+    static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
+    static String keyspaceName = "testCassa";
+    static String tableName = "employees";
+    static String xLatestVersion = "X-latestVersion";
+    static String onboardUUID = null;
+    static String lockId = null;
+    static String lockName = "testCassa.employees.sample3";
+
+    @BeforeClass
+    public static void init() throws Exception {
+        try {
+            MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
+            zkServer = new TestingServer(2181, new File("/tmp/zk"));
+            MusicCore.mLockHandle = new MusicLockingService();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @AfterClass
+    public static void tearDownAfterClass() throws Exception {
+        System.out.println("After class");
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
+        MusicCore.eventualPut(testObject);
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
+        MusicCore.eventualPut(testObject);
+        MusicCore.mDstoreHandle.close();
+        MusicCore.mLockHandle.getzkLockHandle().close();
+        MusicCore.mLockHandle.close();
+        zkServer.stop();
+    }
+
+    @Test
+    public void Test1_createKeyspace() throws Exception {
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = "
+                        + "{'class' : 'SimpleStrategy' , "
+                        + "'replication_factor': 1} AND DURABLE_WRITES = true");
+        MusicCore.eventualPut(testObject);
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(
+                        "CREATE TABLE admin.keyspace_master (" + "  uuid uuid, keyspace_name text,"
+                                        + "  application_name text, is_api boolean,"
+                                        + "  password text, username text,"
+                                        + "  is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
+        MusicCore.eventualPut(testObject);
+
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(
+                        "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
+                                        + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
+                        MusicUtil.DEFAULTKEYSPACENAME));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
+        MusicCore.eventualPut(testObject);
+
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(
+                        "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
+                                        + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
+                        UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
+                        MusicUtil.DEFAULTKEYSPACENAME));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
+        MusicCore.eventualPut(testObject);
+
+        testObject = new PreparedQueryObject();
+        testObject.appendQueryString(
+                        "select uuid from admin.keyspace_master where application_name = ? allow filtering");
+        testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
+        ResultSet rs = MusicCore.get(testObject);
+        List<Row> rows = rs.all();
+        if (rows.size() > 0) {
+            System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
+        }
+    }
+
+    @Test
+    public void Test2_createKeyspace() throws Exception {
+        JsonKeySpace jsonKeyspace = new JsonKeySpace();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> replicationInfo = new HashMap<>();
+        consistencyInfo.put("type", "eventual");
+        replicationInfo.put("class", "SimpleStrategy");
+        replicationInfo.put("replication_factor", 1);
+        jsonKeyspace.setConsistencyInfo(consistencyInfo);
+        jsonKeyspace.setDurabilityOfWrites("true");
+        jsonKeyspace.setKeyspaceName(keyspaceName);
+        jsonKeyspace.setReplicationInfo(replicationInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.createKeySpace("1", "1", "1", null, appName, userId,
+                        password, jsonKeyspace, keyspaceName);
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertEquals(200,response.getStatus());
+    }
+
+    @Test
+    public void Test2_createKeyspace0() throws Exception {
+        JsonKeySpace jsonKeyspace = new JsonKeySpace();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> replicationInfo = new HashMap<>();
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.createKeySpace("1", "1", "1", null, appName, userId,
+                        password, jsonKeyspace, keyspaceName);
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertEquals(400,response.getStatus());
+    }
+//MusicCore.autheticateUser
+    @Test
+    public void Test2_createKeyspace01() throws Exception {
+        JsonKeySpace jsonKeyspace = new JsonKeySpace();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> replicationInfo = new HashMap<>();
+        String appName1 = "test";
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.createKeySpace("1", "1", "1", null, appName1, userId,
+                        password, jsonKeyspace, keyspaceName);
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertEquals(401,response.getStatus());
+    }
+
+    @Test
+    public void Test3_createKeyspace1() throws Exception {
+        JsonKeySpace jsonKeyspace = new JsonKeySpace();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> replicationInfo = new HashMap<>();
+        consistencyInfo.put("type", "eventual");
+        replicationInfo.put("class", "SimpleStrategy");
+        replicationInfo.put("replication_factor", 1);
+        jsonKeyspace.setConsistencyInfo(consistencyInfo);
+        jsonKeyspace.setDurabilityOfWrites("true");
+        jsonKeyspace.setKeyspaceName("TestApp1");
+        jsonKeyspace.setReplicationInfo(replicationInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.createKeySpace("1", "1", "1", null, "TestApp1",
+                        "TestUser1", password, jsonKeyspace, keyspaceName);
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertEquals(400,response.getStatus());
+    }
+
+    @Test
+    public void Test3_createTable() throws Exception {
+        JsonTable jsonTable = new JsonTable();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, String> fields = new HashMap<>();
+        fields.put("uuid", "text");
+        fields.put("emp_name", "text");
+        fields.put("emp_salary", "varint");
+        fields.put("PRIMARY KEY", "(emp_name)");
+        consistencyInfo.put("type", "eventual");
+        jsonTable.setConsistencyInfo(consistencyInfo);
+        jsonTable.setKeyspaceName(keyspaceName);
+        jsonTable.setPrimaryKey("emp_name");
+        jsonTable.setTableName(tableName);
+        jsonTable.setFields(fields);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.createTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                        jsonTable, keyspaceName, tableName);
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertEquals(200, response.getStatus());
+    }
+
+    // Improper Auth
+    @Test
+    public void Test3_createTable1() throws Exception {
+        JsonTable jsonTable = new JsonTable();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, String> fields = new HashMap<>();
+        fields.put("uuid", "text");
+        fields.put("emp_name", "text");
+        fields.put("emp_salary", "varint");
+        fields.put("PRIMARY KEY", "(emp_name)");
+        consistencyInfo.put("type", "eventual");
+        jsonTable.setConsistencyInfo(consistencyInfo);
+        jsonTable.setKeyspaceName(keyspaceName);
+        jsonTable.setPrimaryKey("emp_name");
+        jsonTable.setTableName(tableName);
+        jsonTable.setFields(fields);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.createTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, "wrong",
+                        jsonTable, keyspaceName, tableName);
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertEquals(401, response.getStatus());
+    }
+
+    // Improper keyspace
+    @Test
+    public void Test3_createTable2() throws Exception {
+        JsonTable jsonTable = new JsonTable();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, String> fields = new HashMap<>();
+        fields.put("uuid", "text");
+        fields.put("emp_name", "text");
+        fields.put("emp_salary", "varint");
+        fields.put("PRIMARY KEY", "(emp_name)");
+        consistencyInfo.put("type", "eventual");
+        jsonTable.setConsistencyInfo(consistencyInfo);
+        jsonTable.setKeyspaceName(keyspaceName);
+        jsonTable.setPrimaryKey("emp_name");
+        jsonTable.setTableName(tableName);
+        jsonTable.setFields(fields);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.createTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                        jsonTable, "wrong", tableName);
+        System.out.println("#######status is " + response.getStatus());
+        System.out.println("Entity" + response.getEntity());
+        assertEquals(401, response.getStatus());
+    }
+
+
+
+    @Test
+    public void Test4_insertIntoTable() throws Exception {
+        JsonInsert jsonInsert = new JsonInsert();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> values = new HashMap<>();
+        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+        values.put("emp_name", "testName");
+        values.put("emp_salary", 500);
+        consistencyInfo.put("type", "eventual");
+        jsonInsert.setConsistencyInfo(consistencyInfo);
+        jsonInsert.setKeyspaceName(keyspaceName);
+        jsonInsert.setTableName(tableName);
+        jsonInsert.setValues(values);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+                appName, userId, password, jsonInsert, keyspaceName, tableName);
+        assertEquals(200, response.getStatus());
+    }
+
+    @Test
+    public void Test4_insertIntoTable2() throws Exception {
+        JsonInsert jsonInsert = new JsonInsert();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> values = new HashMap<>();
+        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+        values.put("emp_name", "test1");
+        values.put("emp_salary", 1500);
+        consistencyInfo.put("type", "eventual");
+        jsonInsert.setConsistencyInfo(consistencyInfo);
+        jsonInsert.setKeyspaceName(keyspaceName);
+        jsonInsert.setTableName(tableName);
+        jsonInsert.setValues(values);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.insertIntoTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                        jsonInsert, keyspaceName, tableName);
+        assertEquals(200, response.getStatus());
+    }
+
+    // Auth Error
+    @Test
+    public void Test4_insertIntoTable3() throws Exception {
+        JsonInsert jsonInsert = new JsonInsert();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> values = new HashMap<>();
+        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+        values.put("emp_name", "test1");
+        values.put("emp_salary", 1500);
+        consistencyInfo.put("type", "eventual");
+        jsonInsert.setConsistencyInfo(consistencyInfo);
+        jsonInsert.setKeyspaceName(keyspaceName);
+        jsonInsert.setTableName(tableName);
+        jsonInsert.setValues(values);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.insertIntoTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, "wrong",
+                        jsonInsert, keyspaceName, tableName);
+        assertEquals(401, response.getStatus());
+    }
+
+    // Table wrong
+    @Test
+    public void Test4_insertIntoTable4() throws Exception {
+        JsonInsert jsonInsert = new JsonInsert();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> values = new HashMap<>();
+        values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+        values.put("emp_name", "test1");
+        values.put("emp_salary", 1500);
+        consistencyInfo.put("type", "eventual");
+        jsonInsert.setConsistencyInfo(consistencyInfo);
+        jsonInsert.setKeyspaceName(keyspaceName);
+        jsonInsert.setTableName(tableName);
+        jsonInsert.setValues(values);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.insertIntoTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                        jsonInsert, keyspaceName, "wrong");
+        assertEquals(400, response.getStatus());
+    }
+    
+    
+    
+    @Test
+    public void Test5_updateTable() throws Exception {
+        JsonUpdate jsonUpdate = new JsonUpdate();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+        Map<String, Object> values = new HashMap<>();
+        row.add("emp_name", "testName");
+        values.put("emp_salary", 2500);
+        consistencyInfo.put("type", "atomic");
+        jsonUpdate.setConsistencyInfo(consistencyInfo);
+        jsonUpdate.setKeyspaceName(keyspaceName);
+        jsonUpdate.setTableName(tableName);
+        jsonUpdate.setValues(values);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Mockito.when(info.getQueryParameters()).thenReturn(row);
+        Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+                userId, password, jsonUpdate, keyspaceName, tableName, info);
+        assertEquals(200, response.getStatus());
+    }
+
+    @Test
+    public void Test6_select() throws Exception {
+        JsonSelect jsonSelect = new JsonSelect();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+        row.add("emp_name", "testName");
+        consistencyInfo.put("type", "atomic");
+        jsonSelect.setConsistencyInfo(consistencyInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Mockito.when(info.getQueryParameters()).thenReturn(row);
+        Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6", 
+                        appName, userId, password, keyspaceName, tableName, info);
+        HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
+        HashMap<String, Object> result = map.get("result");
+        assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
+    }
+
+    @Test
+    public void Test6_selectCritical() throws Exception {
+        JsonInsert jsonInsert = new JsonInsert();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+        row.add("emp_name", "testName");
+        consistencyInfo.put("type", "atomic");
+        jsonInsert.setConsistencyInfo(consistencyInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Mockito.when(info.getQueryParameters()).thenReturn(row);
+        Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6", 
+                        appName, userId, password, jsonInsert, keyspaceName, tableName,info);
+        HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
+        HashMap<String, Object> result = map.get("result");
+        assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
+    }
+
+    @Test
+    public void Test6_deleteFromTable() throws Exception {
+        JsonDelete jsonDelete = new JsonDelete();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+        row.add("emp_name", "test1");
+        consistencyInfo.put("type", "atomic");
+        jsonDelete.setConsistencyInfo(consistencyInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Mockito.when(info.getQueryParameters()).thenReturn(row);
+        Response response = data.deleteFromTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                        jsonDelete, keyspaceName, tableName, info);
+        assertEquals(200, response.getStatus());
+    }
+
+    // Values
+    @Test
+    public void Test6_deleteFromTable1() throws Exception {
+        JsonDelete jsonDelete = new JsonDelete();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+        consistencyInfo.put("type", "atomic");
+        jsonDelete.setConsistencyInfo(consistencyInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Mockito.when(info.getQueryParameters()).thenReturn(row);
+        Response response = data.deleteFromTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                        jsonDelete, keyspaceName, tableName, info);
+        assertEquals(400, response.getStatus());
+    }
+
+    // delObj
+    @Test
+    public void Test6_deleteFromTable2() throws Exception {
+        JsonDelete jsonDelete = new JsonDelete();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+        row.add("emp_name", "test1");
+        consistencyInfo.put("type", "atomic");
+        jsonDelete.setConsistencyInfo(consistencyInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Mockito.when(info.getQueryParameters()).thenReturn(row);
+        Response response = data.deleteFromTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                        null, keyspaceName, tableName, info);
+        assertEquals(400, response.getStatus());
+    }
+
+    @Test
+    public void Test7_dropTable() throws Exception {
+        JsonTable jsonTable = new JsonTable();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        consistencyInfo.put("type", "atomic");
+        jsonTable.setConsistencyInfo(consistencyInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.dropTable("1", "1", "1",
+                        "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+                         keyspaceName, tableName);
+        assertEquals(200, response.getStatus());
+    }
+
+    @Test
+    public void Test8_deleteKeyspace() throws Exception {
+        JsonKeySpace jsonKeyspace = new JsonKeySpace();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> replicationInfo = new HashMap<>();
+        consistencyInfo.put("type", "eventual");
+        replicationInfo.put("class", "SimpleStrategy");
+        replicationInfo.put("replication_factor", 1);
+        jsonKeyspace.setConsistencyInfo(consistencyInfo);
+        jsonKeyspace.setDurabilityOfWrites("true");
+        jsonKeyspace.setKeyspaceName("TestApp1");
+        jsonKeyspace.setReplicationInfo(replicationInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+                appName, userId, password, keyspaceName);
+        assertEquals(200, response.getStatus());
+    }
+    
+    @Test
+    public void Test8_deleteKeyspace2() throws Exception {
+        JsonKeySpace jsonKeyspace = new JsonKeySpace();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> replicationInfo = new HashMap<>();
+        consistencyInfo.put("type", "eventual");
+        replicationInfo.put("class", "SimpleStrategy");
+        replicationInfo.put("replication_factor", 1);
+        jsonKeyspace.setConsistencyInfo(consistencyInfo);
+        jsonKeyspace.setDurabilityOfWrites("true");
+        jsonKeyspace.setKeyspaceName("TestApp1");
+        jsonKeyspace.setReplicationInfo(replicationInfo);
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+                appName, userId, "wrong", keyspaceName);
+        assertEquals(401, response.getStatus());
+    }
+
+    @Test
+    public void Test8_deleteKeyspace3() throws Exception {
+        JsonKeySpace jsonKeyspace = new JsonKeySpace();
+        Map<String, String> consistencyInfo = new HashMap<>();
+        Map<String, Object> replicationInfo = new HashMap<>();
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+                appName, userId, password, keyspaceName);
+        assertEquals(400, response.getStatus());
+    }
+
+    
+    
+    @Test
+    public void Test6_onboard() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setAppname("TestApp2");
+        jsonOnboard.setIsAAF("false");
+        jsonOnboard.setUserId("TestUser2");
+        jsonOnboard.setPassword("TestPassword2");
+        Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
+        resultMap.containsKey("success");
+        onboardUUID = resultMap.get("Generated AID").toString();
+        assertEquals("Your application TestApp2 has been onboarded with MUSIC.", resultMap.get("Success"));
+    }
+    // Missing appname
+    @Test
+    public void Test6_onboard1() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setIsAAF("false");
+        jsonOnboard.setUserId("TestUser2");
+        jsonOnboard.setPassword("TestPassword2");
+        Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
+        resultMap.containsKey("success");
+        System.out.println("--->" + resultMap.toString());
+        assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
+    }
+
+    
+    @Test
+    public void Test7_onboardSearch() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setAppname("TestApp2");
+        jsonOnboard.setIsAAF("false");
+        jsonOnboard.setAid(onboardUUID);
+        Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
+        resultMap.containsKey("success");
+        assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
+
+    }
+
+    // Missing appname
+    @Test
+    public void Test7_onboardSearch1() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setIsAAF("false");
+        jsonOnboard.setAid(onboardUUID);
+        Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
+        System.out.println("--->" + resultMap.toString());
+        resultMap.containsKey("success");
+        assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
+
+    }
+
+    @Test
+    public void Test8_onboardUpdate() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setIsAAF("false");
+        jsonOnboard.setUserId("TestUser3");
+        jsonOnboard.setPassword("TestPassword3");
+        jsonOnboard.setAid(onboardUUID);
+        Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
+        System.out.println("--->" + resultMap.toString());
+        resultMap.containsKey("success");
+        assertEquals("Your application has been updated successfully", resultMap.get("Success"));
+    }
+
+    // Aid null
+    @Test
+    public void Test8_onboardUpdate1() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setIsAAF("false");
+        jsonOnboard.setUserId("TestUser3");
+        jsonOnboard.setPassword("TestPassword3");
+        Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
+        System.out.println("--->" + resultMap.toString());
+        resultMap.containsKey("success");
+        assertEquals("Please make sure Aid is present", resultMap.get("Exception"));
+    }
+
+    // Appname not null
+    @Test
+    public void Test8_onboardUpdate2() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setAppname("TestApp2");
+        jsonOnboard.setIsAAF("false");
+        jsonOnboard.setUserId("TestUser3");
+        jsonOnboard.setPassword("TestPassword3");
+        jsonOnboard.setAid(onboardUUID);
+        Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
+        resultMap.containsKey("success");
+        System.out.println("--->" + resultMap.toString());
+        assertEquals("Application TestApp2 has already been onboarded. Please contact admin.", resultMap.get("Exception"));
+    }
+
+    // All null
+    @Test
+    public void Test8_onboardUpdate3() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setAid(onboardUUID);
+        Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
+        assertTrue(resultMap.containsKey("Exception") );
+    }
+
+    @Test
+    public void Test9_onboardDelete() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        jsonOnboard.setAppname("TestApp2");
+        jsonOnboard.setAid(onboardUUID);
+        Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
+        resultMap.containsKey("success");
+        assertEquals("Your application has been deleted successfully", resultMap.get("Success"));
+    }
+
+    @Test
+    public void Test9_onboardDelete1() throws Exception {
+        JsonOnboard jsonOnboard = new JsonOnboard();
+        Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
+        assertTrue(resultMap.containsKey("Exception"));
+    }
+
+    @Test
+    public void Test3_createLockReference() throws Exception {
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1", null, appName, userId, password).getEntity();
+        @SuppressWarnings("unchecked")
+        Map<String, Object> resultMap1 = (Map<String, Object>) resultMap.get("lock");
+        lockId = (String) resultMap1.get("lock");
+        assertEquals(ResultType.SUCCESS, resultMap.get("status"));
+    }
+
+    @Test
+    public void Test4_accquireLock() throws Exception {
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLock(lockId,"1","1", null, appName, userId, password).getEntity();
+        assertEquals(ResultType.SUCCESS, resultMap.get("status"));
+    }
+
+    @Test
+    public void Test5_currentLockHolder() throws Exception {
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder(lockName,"1","1", null, appName, userId, password).getEntity();
+        assertEquals(ResultType.SUCCESS, resultMap.get("status"));
+    }
+
+    @Test
+    public void Test7_unLock() throws Exception {
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Map<String, Object> resultMap = (Map<String, Object>) lock.unLock(lockId,"1","1", null, appName, userId, password).getEntity();
+        assertEquals(ResultType.SUCCESS, resultMap.get("status"));
+    }
+
+    @Test
+    public void Test8_delete() throws Exception {
+        Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+        Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null, appName, userId, password).getEntity();
+        assertEquals(ResultType.SUCCESS, resultMap.get("status"));
+    }
+}
\ No newline at end of file
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/AAFResponseTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/AAFResponseTest.java
new file mode 100644
index 00000000..354668c7
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/AAFResponseTest.java
@@ -0,0 +1,54 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import java.util.ArrayList;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.AAFResponse;
+import org.onap.music.datastore.jsonobjects.NameSpace;
+
+public class AAFResponseTest {
+
+    @Test
+    public void testGetNs() {
+        NameSpace ns = new NameSpace();
+        AAFResponse ar = new AAFResponse();
+        ArrayList<NameSpace> nsArray = new ArrayList<>();
+        ns.setName("tom");
+        ArrayList<String> admin = new ArrayList<>();
+        admin.add("admin1");
+        ns.setAdmin(admin);
+        nsArray.add(ns);
+        ar.setNs(nsArray);
+        assertEquals("tom",ar.getNs().get(0).getName());
+        assertEquals("admin1",ar.getNs().get(0).getAdmin().get(0));
+        
+    }
+
+//    @Test
+//    public void testSetNs() {
+//        fail("Not yet implemented");
+//    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonDeleteTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonDeleteTest.java
new file mode 100644
index 00000000..885694bd
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonDeleteTest.java
@@ -0,0 +1,86 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+
+public class JsonDeleteTest {
+    
+    JsonDelete jd = null;
+    
+    @Before
+    public void init() {
+        jd = new JsonDelete();
+    }
+    
+    
+    @Test
+    public void testGetConditions() {
+        Map<String,Object>  mapSo = new HashMap<>();
+        mapSo = new HashMap<>();
+        mapSo.put("key1","one");
+        mapSo.put("key2","two");
+        jd.setConditions(mapSo);
+        assertEquals("one",jd.getConditions().get("key1"));
+    }
+
+    @Test
+    public void testGetConsistencyInfo() {
+        Map<String,String>  mapSs = new HashMap<>();
+        mapSs = new HashMap<>();
+        mapSs.put("key3","three");
+        mapSs.put("key4","four");
+        jd.setConsistencyInfo(mapSs);
+        assertEquals("three",jd.getConsistencyInfo().get("key3"));
+    }
+
+    @Test
+    public void testGetColumns() {
+        ArrayList<String> ary = new ArrayList<>();
+        ary = new ArrayList<>();
+        ary.add("e1");
+        ary.add("e2");
+        ary.add("e3");
+        jd.setColumns(ary);
+        assertEquals("e1",jd.getColumns().get(0));
+    }
+
+    @Test
+    public void testGetTtl() {
+        jd.setTtl("2000");
+        assertEquals("2000",jd.getTtl());
+    }
+
+    @Test
+    public void testGetTimestamp() {
+        jd.setTimestamp("20:00");
+        assertEquals("20:00",jd.getTimestamp());
+
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonInsertTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonInsertTest.java
new file mode 100644
index 00000000..69403cc7
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonInsertTest.java
@@ -0,0 +1,86 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+
+public class JsonInsertTest {
+    
+    JsonInsert ji = new JsonInsert();
+
+    @Test
+    public void testGetKeyspaceName() {
+        ji.setKeyspaceName("keyspace");
+        assertEquals("keyspace",ji.getKeyspaceName());
+    }
+
+    @Test
+    public void testGetTableName() {
+        ji.setTableName("table");
+        assertEquals("table",ji.getTableName());
+    }
+
+    @Test
+    public void testGetConsistencyInfo() {
+        Map<String,String> cons = new HashMap<>();
+        cons.put("test","true");
+        ji.setConsistencyInfo(cons);
+        assertEquals("true",ji.getConsistencyInfo().get("test"));
+    }
+
+    @Test
+    public void testGetTtl() {
+        ji.setTtl("ttl");
+        assertEquals("ttl",ji.getTtl());
+    }
+
+    @Test
+    public void testGetTimestamp() {
+        ji.setTimestamp("10:30");
+        assertEquals("10:30",ji.getTimestamp());
+    }
+
+    @Test
+    public void testGetValues() {
+        Map<String,Object> cons = new HashMap<>();
+        cons.put("val1","one");
+        cons.put("val2","two");
+        ji.setValues(cons);
+        assertEquals("one",ji.getValues().get("val1"));
+    }
+
+    @Test
+    public void testGetRow_specification() {
+        Map<String,Object> cons = new HashMap<>();
+        cons.put("val1","one");
+        cons.put("val2","two");
+        ji.setRow_specification(cons);
+        assertEquals("two",ji.getRow_specification().get("val2"));
+    }
+
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonKeySpaceTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonKeySpaceTest.java
new file mode 100644
index 00000000..882d5d5e
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonKeySpaceTest.java
@@ -0,0 +1,72 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+
+public class JsonKeySpaceTest {
+
+    JsonKeySpace jk = null;
+    
+    
+    @Before
+    public void init() {
+        jk = new JsonKeySpace();
+    }
+                    
+                
+    
+    @Test
+    public void testGetConsistencyInfo() {
+        Map<String, String> mapSs = new HashMap<>();
+        mapSs.put("k1", "one");
+        jk.setConsistencyInfo(mapSs);
+        assertEquals("one",jk.getConsistencyInfo().get("k1"));
+    }
+
+    @Test
+    public void testGetReplicationInfo() {
+        Map<String,Object> mapSo = new HashMap<>();
+        mapSo.put("k1", "one");
+        jk.setReplicationInfo(mapSo);
+        assertEquals("one",jk.getReplicationInfo().get("k1"));
+
+    }
+
+    @Test
+    public void testGetDurabilityOfWrites() {
+        jk.setDurabilityOfWrites("1");
+        assertEquals("1",jk.getDurabilityOfWrites());
+    }
+
+    @Test
+    public void testGetKeyspaceName() {
+        jk.setKeyspaceName("Keyspace");
+        assertEquals("Keyspace",jk.getKeyspaceName());
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonLeasedLockTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonLeasedLockTest.java
new file mode 100644
index 00000000..63f901c6
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonLeasedLockTest.java
@@ -0,0 +1,53 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonLeasedLock;
+
+public class JsonLeasedLockTest {
+
+    JsonLeasedLock jl = null;
+    
+    @Before
+    public void init() {
+        jl = new JsonLeasedLock();
+    }
+    
+    
+    @Test
+    public void testGetLeasePeriod() {
+        long lease = 20000;
+        jl.setLeasePeriod(lease);
+        assertEquals(lease,jl.getLeasePeriod());
+    }
+
+    @Test
+    public void testGetNotifyUrl() {
+        String url = "http://somewhere.com";
+        jl.setNotifyUrl(url);
+        assertEquals(url,jl.getNotifyUrl());
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonOnboardTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonOnboardTest.java
new file mode 100644
index 00000000..82f1748a
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonOnboardTest.java
@@ -0,0 +1,78 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonOnboard;
+
+public class JsonOnboardTest {
+
+    JsonOnboard jo = null;
+    
+    @Before
+    public void init() {
+        jo = new JsonOnboard();
+    }
+
+    
+    @Test
+    public void testGetPassword() {
+        String password = "password";
+        jo.setPassword(password);
+        assertEquals(password,jo.getPassword());
+    }
+
+    @Test
+    public void testGetAid() {
+        String aid = "aid";
+        jo.setAid(aid);
+        assertEquals(aid,jo.getAid());
+
+    }
+
+    @Test
+    public void testGetAppname() {
+        String appName = "appName";
+        jo.setAppname(appName);
+        assertEquals(appName,jo.getAppname());
+
+    }
+
+    @Test
+    public void testGetUserId() {
+        String userId = "userId";
+        jo.setUserId(userId);
+        assertEquals(userId,jo.getUserId());
+
+    }
+
+    @Test
+    public void testGetIsAAF() {
+        String aaf = "true";
+        jo.setIsAAF(aaf);
+        assertEquals(aaf,jo.getIsAAF());
+        
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonSelectTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonSelectTest.java
new file mode 100644
index 00000000..0243232f
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonSelectTest.java
@@ -0,0 +1,41 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonSelect;
+
+public class JsonSelectTest {
+
+    @Test
+    public void testGetConsistencyInfo() {
+        JsonSelect js = new JsonSelect();
+        Map<String, String> mapSs = new HashMap<>();
+        mapSs.put("k1", "one");
+        js.setConsistencyInfo(mapSs);
+        assertEquals("one",js.getConsistencyInfo().get("k1"));
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonTableTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonTableTest.java
new file mode 100644
index 00000000..e4c800fc
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonTableTest.java
@@ -0,0 +1,99 @@
+/*
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2017 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonTable;
+
+public class JsonTableTest {
+
+    JsonTable jt = null;
+    
+    @Before
+    public void init() {
+        jt = new JsonTable();
+    }
+    
+    @Test
+    public void testGetConsistencyInfo() {
+        Map<String, String> mapSs = new HashMap<>();
+        mapSs.put("k1", "one");
+        jt.setConsistencyInfo(mapSs);
+        assertEquals("one",jt.getConsistencyInfo().get("k1"));
+    }
+
+    @Test
+    public void testGetProperties() {
+        Map<String, Object> properties = new HashMap<>();
+        properties.put("k1", "one");
+        jt.setProperties(properties);
+    }
+
+    @Test
+    public void testGetFields() {
+        Map<String, String> fields = new HashMap<>();
+        fields.put("k1", "one");
+        jt.setFields(fields);
+        assertEquals("one",jt.getFields().get("k1"));
+    }
+
+    @Test
+    public void testGetKeyspaceName() {
+        String keyspace = "keyspace";
+        jt.setKeyspaceName(keyspace);
+        assertEquals(keyspace,jt.getKeyspaceName());
+    }
+
+    @Test
+    public void testGetTableName() {
+        String table = "table";
+        jt.setTableName(table);
+        assertEquals(table,jt.getTableName());
+   }
+
+    @Test
+    public void testGetSortingKey() {
+        String sortKey = "sortkey";
+        jt.setSortingKey(sortKey);
+        assertEquals(sortKey,jt.getSortingKey());
+    }
+
+    @Test
+    public void testGetClusteringOrder() {
+        String clusteringOrder = "clusteringOrder";
+        jt.setClusteringOrder(clusteringOrder);
+        assertEquals(clusteringOrder,jt.getClusteringOrder());
+    }
+
+    @Test
+    public void testGetPrimaryKey() {
+        String primaryKey = "primaryKey";
+        jt.setPrimaryKey(primaryKey);
+        assertEquals(primaryKey,jt.getPrimaryKey());        
+    }
+
+}
diff --git a/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonUpdateTest.java b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonUpdateTest.java
new file mode 100644
index 00000000..54db0540
--- /dev/null
+++ b/jar/src/test/java/org/onap/music/unittests/jsonobjects/JsonUpdateTest.java
@@ -0,0 +1,103 @@
+/*******************************************************************************
+ * ============LICENSE_START==========================================
+ * org.onap.music
+ * ===================================================================
+ *  Copyright (c) 2018 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.unittests.jsonobjects;
+
+import static org.junit.Assert.*;
+import java.util.HashMap;
+import java.util.Map;
+import org.junit.Before;
+import org.junit.Test;
+import org.onap.music.datastore.jsonobjects.JsonUpdate;
+
+public class JsonUpdateTest {
+    
+    JsonUpdate ju = null;
+    
+    @Before
+    public void init() {
+        ju = new JsonUpdate();
+    }
+    
+
+    @Test
+    public void testGetConditions() {
+        Map<String,Object>  mapSo = new HashMap<>();
+        mapSo.put("key1","one");
+        mapSo.put("key2","two");
+        ju.setConditions(mapSo);
+        assertEquals("one",ju.getConditions().get("key1"));
+    }
+
+    @Test
+    public void testGetRow_specification() {
+        Map<String,Object>  mapSo = new HashMap<>();
+        mapSo.put("key1","one");
+        mapSo.put("key2","two");
+        ju.setRow_specification(mapSo);
+        assertEquals("one",ju.getRow_specification().get("key1"));
+    }
+
+    @Test
+    public void testGetKeyspaceName() {
+        String keyspace = "keyspace";
+        ju.setKeyspaceName(keyspace);
+        assertEquals(keyspace,ju.getKeyspaceName());
+    }
+
+    @Test
+    public void testGetTableName() {
+        String table = "table";
+        ju.setTableName(table);
+        assertEquals(table,ju.getTableName());
+   }
+
+    @Test
+    public void testGetConsistencyInfo() {
+        Map<String, String> mapSs = new HashMap<>();
+        mapSs.put("k1", "one");
+        ju.setConsistencyInfo(mapSs);
+        assertEquals("one",ju.getConsistencyInfo().get("k1"));
+    }
+
+    @Test
+    public void testGetTtl() {
+        ju.setTtl("2000");
+        assertEquals("2000",ju.getTtl());
+    }
+
+    @Test
+    public void testGetTimestamp() {
+        ju.setTimestamp("20:00");
+        assertEquals("20:00",ju.getTimestamp());
+
+    }
+
+    @Test
+    public void testGetValues() {
+        Map<String,Object> cons = new HashMap<>();
+        cons.put("val1","one");
+        cons.put("val2","two");
+        ju.setValues(cons);
+        assertEquals("one",ju.getValues().get("val1"));
+    }
+
+}