src/test/java/org/onap/music/unittests/TestRestMusicData.java

   1 /*
   2  * ============LICENSE_START========================================== org.onap.music
   3  * =================================================================== Copyright (c) 2017 AT&T
   4  * Intellectual Property ===================================================================
   5  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
   6  * in compliance with the License. You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software distributed under the License
  11  * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  12  * or implied. See the License for the specific language governing permissions and limitations under
  13  * the License.
  14  *
  15  * ============LICENSE_END=============================================
  16  * ====================================================================
  17  */
  18 package org.onap.music.unittests;
  19
  20 import static org.junit.Assert.assertEquals;
  21 import static org.junit.Assert.assertFalse;
  22 import static org.junit.Assert.assertNotEquals;
  23 import static org.junit.Assert.assertNotNull;
  24 import static org.junit.Assert.assertTrue;
  25 import static org.onap.music.main.MusicCore.mLockHandle;
  26
  27 import java.io.File;
  28 import java.util.ArrayList;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.UUID;
  33 import javax.servlet.http.HttpServletResponse;
  34 import javax.ws.rs.core.MultivaluedMap;
  35 import javax.ws.rs.core.Response;
  36 import javax.ws.rs.core.UriInfo;
  37 import org.apache.curator.test.TestingServer;
  38 import org.apache.http.impl.client.AutoRetryHttpClient;
  39 import org.junit.AfterClass;
  40 import org.junit.BeforeClass;
  41 import org.junit.FixMethodOrder;
  42 import org.junit.Test;
  43 import org.junit.runner.RunWith;
  44 import org.junit.runners.MethodSorters;
  45 import org.mindrot.jbcrypt.BCrypt;
  46 import org.mockito.InjectMocks;
  47 import org.mockito.Mock;
  48 import org.mockito.Mockito;
  49 import org.mockito.MockitoAnnotations;
  50 import org.mockito.runners.MockitoJUnitRunner;
  51 import org.onap.music.conductor.conditionals.JsonConditional;
  52 import org.onap.music.conductor.conditionals.MusicConditional;
  53 import org.onap.music.conductor.conditionals.RestMusicConditionalAPI;
  54 import org.onap.music.datastore.PreparedQueryObject;
  55 import org.onap.music.datastore.jsonobjects.JsonDelete;
  56 import org.onap.music.datastore.jsonobjects.JsonInsert;
  57 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
  58 import org.onap.music.datastore.jsonobjects.JsonOnboard;
  59 import org.onap.music.datastore.jsonobjects.JsonSelect;
  60 import org.onap.music.datastore.jsonobjects.JsonTable;
  61 import org.onap.music.datastore.jsonobjects.JsonUpdate;
  62 import org.onap.music.exceptions.MusicServiceException;
  63 import org.onap.music.lockingservice.MusicLockState;
  64 import org.onap.music.lockingservice.MusicLockingService;
  65 import org.onap.music.lockingservice.MusicLockState.LockStatus;
  66 import org.onap.music.main.CachingUtil;
  67 import org.onap.music.main.MusicCore;
  68 import org.onap.music.main.MusicUtil;
  69 import org.onap.music.main.ResultType;
  70 import org.onap.music.main.ReturnType;
  71 import org.onap.music.rest.RestMusicAdminAPI;
  72 import org.onap.music.rest.RestMusicBmAPI;
  73 import org.onap.music.rest.RestMusicDataAPI;
  74 import org.onap.music.rest.RestMusicHealthCheckAPI;
  75 import org.onap.music.rest.RestMusicLocksAPI;
  76 import org.onap.music.rest.RestMusicTestAPI;
  77 import org.onap.music.rest.RestMusicVersionAPI;
  78
  79 import com.datastax.driver.core.ConsistencyLevel;
  80 import com.datastax.driver.core.DataType;
  81 import com.datastax.driver.core.ResultSet;
  82 import com.datastax.driver.core.Row;
  83 import com.sun.jersey.core.util.Base64;
  84 import com.sun.jersey.core.util.MultivaluedMapImpl;
  85
  86 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  87 @RunWith(MockitoJUnitRunner.class)
  88 public class TestRestMusicData {
  89
  90     RestMusicDataAPI data = new RestMusicDataAPI();
  91     RestMusicAdminAPI admin = new RestMusicAdminAPI();
  92     RestMusicLocksAPI lock = new RestMusicLocksAPI();
  93     static PreparedQueryObject testObject;
  94     static TestingServer zkServer;
  95
  96     @Mock
  97     HttpServletResponse http;
  98
  99     @Mock
 100     UriInfo info;
 101
 102     //* cjc out
 103     @Mock
 104     CachingUtil cachUtilMock;
 105
 106     @InjectMocks
 107       private MusicCore mCore;
 108     //*/
 109
 110     static String appName = "TestApp";
 111     static String userId = "TestUser";
 112     static String password = "TestPassword";
 113     static String authData = userId+":"+password;
 114     static String wrongAuthData = userId+":"+"pass";
 115     static String authorization = new String(Base64.encode(authData.getBytes()));
 116     static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
 117     static boolean isAAF = false;
 118     static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
 119     static String keyspaceName = "testCassa";
 120     static String tableName = "employees";
 121     static String tableNameConditional = "Conductor";
 122     static String xLatestVersion = "X-latestVersion";
 123     static String onboardUUID = null;
 124     static String lockId = null;
 125     static String lockName = "testCassa.employees.sample3";
 126
 127     @BeforeClass
 128     public static void init() throws Exception {
 129        try {
 130             MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
 131             zkServer = new TestingServer(2181, new File("/tmp/zk"));
 132             MusicCore.mLockHandle = new MusicLockingService();
 133         } catch (Exception e) {
 134             e.printStackTrace();
 135         }
 136     }
 137
 138     @AfterClass
 139     public static void tearDownAfterClass() throws Exception {
 140         testObject = new PreparedQueryObject();
 141         testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
 142         MusicCore.eventualPut(testObject);
 143         testObject = new PreparedQueryObject();
 144         testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
 145         MusicCore.eventualPut(testObject);
 146         MusicCore.mDstoreHandle.close();
 147         MusicCore.mLockHandle.getzkLockHandle().close();
 148         MusicCore.mLockHandle.close();
 149         zkServer.stop();
 150     }
 151
 152     @Test
 153     public void Test1_createKeyspace() throws Exception {
 154         testObject = new PreparedQueryObject();
 155         testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = "
 156                         + "{'class' : 'SimpleStrategy' , "
 157                         + "'replication_factor': 1} AND DURABLE_WRITES = true");
 158         MusicCore.eventualPut(testObject);
 159         testObject = new PreparedQueryObject();
 160         testObject.appendQueryString(
 161                         "CREATE TABLE admin.keyspace_master (" + "  uuid uuid, keyspace_name text,"
 162                                         + "  application_name text, is_api boolean,"
 163                                         + "  password text, username text,"
 164                                         + "  is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
 165         MusicCore.eventualPut(testObject);
 166
 167         testObject = new PreparedQueryObject();
 168         testObject.appendQueryString(
 169                         "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
 170                                         + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
 171         testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
 172         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
 173                         MusicUtil.DEFAULTKEYSPACENAME));
 174         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
 175         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
 176         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
 177         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
 178         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
 179         MusicCore.eventualPut(testObject);
 180
 181         testObject = new PreparedQueryObject();
 182         testObject.appendQueryString(
 183                         "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
 184                                         + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
 185         testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
 186                         UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
 187         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
 188                         MusicUtil.DEFAULTKEYSPACENAME));
 189         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
 190         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
 191         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
 192         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
 193         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
 194         MusicCore.eventualPut(testObject);
 195
 196         testObject = new PreparedQueryObject();
 197         testObject.appendQueryString(
 198                         "select uuid from admin.keyspace_master where application_name = ? allow filtering");
 199         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
 200         ResultSet rs = MusicCore.get(testObject);
 201         List<Row> rows = rs.all();
 202         if (rows.size() > 0) {
 203             System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
 204         }
 205     }
 206
 207     @Test
 208     public void Test2_createKeyspace() throws Exception {
 209         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 210         Map<String, String> consistencyInfo = new HashMap<>();
 211         Map<String, Object> replicationInfo = new HashMap<>();
 212         consistencyInfo.put("type", "eventual");
 213         replicationInfo.put("class", "SimpleStrategy");
 214         replicationInfo.put("replication_factor", 1);
 215         jsonKeyspace.setConsistencyInfo(consistencyInfo);
 216         jsonKeyspace.setDurabilityOfWrites("true");
 217         jsonKeyspace.setKeyspaceName(keyspaceName);
 218         jsonKeyspace.setReplicationInfo(replicationInfo);
 219         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 220         Response response = data.createKeySpace("1", "1", "1", null,authorization, appName,  jsonKeyspace, keyspaceName);
 221         System.out.println("#######status is " + response.getStatus());
 222         System.out.println("Entity" + response.getEntity());
 223         assertEquals(200,response.getStatus());
 224     }
 225
 226     @Test
 227     public void Test2_createKeyspace1() throws Exception {
 228         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 229         Map<String, String> consistencyInfo = new HashMap<>();
 230         Map<String, Object> replicationInfo = new HashMap<>();
 231         consistencyInfo.put("type", "eventual");
 232         replicationInfo.put("class", "SimpleStrategy");
 233         replicationInfo.put("replication_factor", 1);
 234         jsonKeyspace.setConsistencyInfo(consistencyInfo);
 235         jsonKeyspace.setDurabilityOfWrites("true");
 236         jsonKeyspace.setKeyspaceName(keyspaceName);
 237         jsonKeyspace.setReplicationInfo(replicationInfo);
 238         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 239         Response response = data.createKeySpace("1", "1", "1", null,authorization, appName,  jsonKeyspace, "keyspaceName");
 240         System.out.println("#######status is " + response.getStatus());
 241         System.out.println("Entity" + response.getEntity());
 242         assertEquals(200,response.getStatus());
 243     }
 244
 245     @Test
 246     public void Test2_createKeyspace0() throws Exception {
 247         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 248         Map<String, String> consistencyInfo = new HashMap<>();
 249         Map<String, Object> replicationInfo = new HashMap<>();
 250         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 251         Response response = data.createKeySpace("1", "1", "1", null, authorization,appName, jsonKeyspace, keyspaceName);
 252         System.out.println("#######status is " + response.getStatus());
 253         System.out.println("Entity" + response.getEntity());
 254         assertEquals(400,response.getStatus());
 255     }
 256 //MusicCore.autheticateUser
 257     @Test
 258     public void Test2_createKeyspace01() throws Exception {
 259         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 260         Map<String, String> consistencyInfo = new HashMap<>();
 261         Map<String, Object> replicationInfo = new HashMap<>();
 262         String appName1 = "test";
 263         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 264         Response response = data.createKeySpace("1", "1", "1", null,authorization, appName1, jsonKeyspace, keyspaceName);
 265         System.out.println("#######status is " + response.getStatus());
 266         System.out.println("Entity" + response.getEntity());
 267         assertEquals(401,response.getStatus());
 268     }
 269
 270     @Test
 271     public void Test3_createKeyspace1() throws Exception {
 272         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 273         Map<String, String> consistencyInfo = new HashMap<>();
 274         Map<String, Object> replicationInfo = new HashMap<>();
 275         consistencyInfo.put("type", "eventual");
 276         replicationInfo.put("class", "SimpleStrategy");
 277         replicationInfo.put("replication_factor", 1);
 278         jsonKeyspace.setConsistencyInfo(consistencyInfo);
 279         jsonKeyspace.setDurabilityOfWrites("true");
 280         jsonKeyspace.setKeyspaceName("TestApp1");
 281         jsonKeyspace.setReplicationInfo(replicationInfo);
 282         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 283         Response response = data.createKeySpace("1", "1", "1", null,authorization, "TestApp1",
 284                          jsonKeyspace, keyspaceName);
 285         System.out.println("#######status is " + response.getStatus());
 286         System.out.println("Entity" + response.getEntity());
 287         assertEquals(401,response.getStatus());
 288     }
 289
 290     @Test
 291     public void Test2_createKeyspaceEmptyAuth() throws Exception {
 292
 293         //MockitoAnnotations.initMocks(this);
 294         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 295         Map<String, String> consistencyInfo = new HashMap<>();
 296         Map<String, Object> replicationInfo = new HashMap<>();
 297         consistencyInfo.put("type", "eventual");
 298         replicationInfo.put("class", "SimpleStrategy");
 299         replicationInfo.put("replication_factor", 1);
 300         jsonKeyspace.setConsistencyInfo(consistencyInfo);
 301         jsonKeyspace.setDurabilityOfWrites("true");
 302         jsonKeyspace.setKeyspaceName(keyspaceName);
 303         jsonKeyspace.setReplicationInfo(replicationInfo);
 304         //Map<String, Object> m1= new HashMap<>() ;
 305         //Mockito.when(CachingUtil.verifyOnboarding("x","y","x")).thenReturn(m1);
 306         //Mockito.when(CachingUtil.verifyOnboarding(appNamex,userId,password).thenReturn(m1));
 307         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 308         String authDatax = ":"+password;
 309         String authorizationx = new String(Base64.encode(authDatax.getBytes()));
 310         try {
 311         Response response = data.createKeySpace("1", "1", "1", null,authorizationx, appName,  jsonKeyspace, keyspaceName);
 312         //System.out.println("#######status is " + response.getStatus());
 313         //System.out.println("Entity" + response.getEntity());
 314         //assertNotEquals(200,response.getStatus());
 315         } catch (RuntimeException e ) {
 316           System.out.println("#######status is runtime exception= " + e);
 317         }
 318     }
 319
 320     @Test
 321     public void Test3_createTable() throws Exception {
 322         JsonTable jsonTable = new JsonTable();
 323         Map<String, String> consistencyInfo = new HashMap<>();
 324         Map<String, String> fields = new HashMap<>();
 325         fields.put("uuid", "text");
 326         fields.put("emp_name", "text");
 327         fields.put("emp_salary", "varint");
 328         fields.put("PRIMARY KEY", "(emp_name)");
 329         consistencyInfo.put("type", "eventual");
 330         jsonTable.setConsistencyInfo(consistencyInfo);
 331         jsonTable.setKeyspaceName(keyspaceName);
 332         jsonTable.setPrimaryKey("emp_name");
 333         jsonTable.setTableName(tableName);
 334         jsonTable.setFields(fields);
 335         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 336         Response response = data.createTable("1", "1", "1",
 337                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
 338                         jsonTable, keyspaceName, tableName);
 339         System.out.println("#######status is " + response.getStatus());
 340         System.out.println("Entity" + response.getEntity());
 341         assertEquals(200, response.getStatus());
 342     }
 343
 344
 345     @Test
 346     public void Test3_createTableClusterOrderBad() throws Exception {
 347         JsonTable jsonTable = new JsonTable();
 348         Map<String, String> consistencyInfo = new HashMap<>();
 349         Map<String, String> fields = new HashMap<>();
 350         fields.put("uuid", "text");
 351         fields.put("emp_name", "text");
 352         fields.put("emp_salary", "varint");
 353         fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
 354         consistencyInfo.put("type", "eventual");
 355         jsonTable.setConsistencyInfo(consistencyInfo);
 356         jsonTable.setKeyspaceName(keyspaceName);
 357         jsonTable.setPrimaryKey("emp_name,emp_salary");
 358         jsonTable.setClusteringOrder("ASC");
 359         jsonTable.setTableName(tableName);
 360         jsonTable.setFields(fields);
 361         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 362         Response response = data.createTable("1", "1", "1",
 363                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
 364                         jsonTable, keyspaceName, tableName);
 365         System.out.println("#######status is " + response.getStatus());
 366         System.out.println("Entity" + response.getEntity());
 367         assertNotEquals(200, response.getStatus());
 368     }
 369
 370     @Test
 371     public void Test3_createTable_withPropertiesNotNull() throws Exception {
 372         JsonTable jsonTable = new JsonTable();
 373         Map<String, String> consistencyInfo = new HashMap<>();
 374         Map<String, String> fields = new HashMap<>();
 375         fields.put("uuid", "text");
 376         fields.put("emp_name", "text");
 377         fields.put("emp_salary", "varint");
 378         fields.put("PRIMARY KEY", "(emp_name)");
 379         consistencyInfo.put("type", "eventual");
 380         Map<String, Object> properties = new HashMap<>();
 381         properties.put("comment","Testing prperties not null");
 382         jsonTable.setConsistencyInfo(consistencyInfo);
 383         jsonTable.setKeyspaceName(keyspaceName);
 384         jsonTable.setPrimaryKey("emp_name");
 385         String tableName_prop=tableName+"_Prop";
 386         jsonTable.setTableName(tableName_prop);
 387         jsonTable.setFields(fields);
 388         jsonTable.setProperties(properties);
 389
 390         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 391         Response response = data.createTable("1", "1", "1",
 392                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
 393                         jsonTable, keyspaceName, tableName_prop);
 394         System.out.println("#######status is " + response.getStatus());
 395         System.out.println("Entity" + response.getEntity());
 396         assertEquals(200, response.getStatus());
 397     }
 398
 399     @Test
 400     public void Test3_createTable_duplicateTable() throws Exception {
 401         JsonTable jsonTable = new JsonTable();
 402         Map<String, String> consistencyInfo = new HashMap<>();
 403         Map<String, String> fields = new HashMap<>();
 404         fields.put("uuid", "text");
 405         fields.put("emp_name", "text");
 406         fields.put("emp_salary", "varint");
 407         fields.put("PRIMARY KEY", "(emp_name)");
 408         consistencyInfo.put("type", "eventual");
 409         jsonTable.setConsistencyInfo(consistencyInfo);
 410         jsonTable.setKeyspaceName(keyspaceName);
 411         jsonTable.setPrimaryKey("emp_name");
 412         String tableNameDup=tableName+"X";
 413         jsonTable.setTableName(tableNameDup);
 414         jsonTable.setFields(fields);
 415         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 416         Response response = data.createTable("1", "1", "1",
 417                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 418                         jsonTable, keyspaceName, tableNameDup);
 419         System.out.println("#######status for 1st time " + response.getStatus());
 420         System.out.println("Entity" + response.getEntity());
 421
 422         Response response0 = data.createTable("1", "1", "1",
 423                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 424                 jsonTable, keyspaceName, tableNameDup);
 425         // 400 is the duplicate status found in response
 426         // Music 113 duplicate testing
 427         //import static org.junit.Assert.assertNotEquals;
 428         System.out.println("#######status for 2nd time " + response0.getStatus());
 429         System.out.println("Entity" + response0.getEntity());
 430
 431         assertFalse("Duplicate table not created for "+tableNameDup, 200==response0.getStatus());
 432
 433     }
 434
 435     // Improper Auth
 436     @Test
 437     public void Test3_createTable1() throws Exception {
 438         JsonTable jsonTable = new JsonTable();
 439         Map<String, String> consistencyInfo = new HashMap<>();
 440         Map<String, String> fields = new HashMap<>();
 441         fields.put("uuid", "text");
 442         fields.put("emp_name", "text");
 443         fields.put("emp_salary", "varint");
 444         fields.put("PRIMARY KEY", "(emp_name)");
 445         consistencyInfo.put("type", "eventual");
 446         jsonTable.setConsistencyInfo(consistencyInfo);
 447         jsonTable.setKeyspaceName(keyspaceName);
 448         jsonTable.setPrimaryKey("emp_name");
 449         jsonTable.setTableName(tableName);
 450         jsonTable.setFields(fields);
 451         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 452         Response response = data.createTable("1", "1", "1",
 453                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
 454                         jsonTable, keyspaceName, tableName);
 455         System.out.println("#######status is " + response.getStatus());
 456         System.out.println("Entity" + response.getEntity());
 457         assertEquals(401, response.getStatus());
 458     }
 459
 460     // Improper keyspace
 461     @Test
 462     public void Test3_createTable3() throws Exception {
 463         JsonTable jsonTable = new JsonTable();
 464         Map<String, String> consistencyInfo = new HashMap<>();
 465         Map<String, String> fields = new HashMap<>();
 466         fields.put("uuid", "text");
 467         fields.put("emp_name", "text");
 468         fields.put("emp_salary", "varint");
 469         fields.put("PRIMARY KEY", "(emp_name)");
 470         consistencyInfo.put("type", "eventual");
 471         jsonTable.setConsistencyInfo(consistencyInfo);
 472         jsonTable.setKeyspaceName(keyspaceName);
 473         jsonTable.setPrimaryKey("emp_name");
 474         jsonTable.setTableName(tableName);
 475         jsonTable.setFields(fields);
 476         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 477         Response response = data.createTable("1", "1", "1",
 478                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 479                         jsonTable, "wrong", tableName);
 480         System.out.println("#######status is " + response.getStatus());
 481         System.out.println("Entity" + response.getEntity());
 482         assertEquals(401, response.getStatus());
 483     }
 484
 485     @Test
 486     public void Test3_createTable3_with_samePartition_clusteringKeys() throws Exception {
 487         JsonTable jsonTable = new JsonTable();
 488         Map<String, String> consistencyInfo = new HashMap<>();
 489         Map<String, String> fields = new HashMap<>();
 490         fields.put("uuid", "text");
 491         fields.put("emp_name", "text");
 492         fields.put("emp_salary", "varint");
 493         fields.put("PRIMARY KEY", "(emp_name, emp_name)");
 494         consistencyInfo.put("type", "eventual");
 495         jsonTable.setConsistencyInfo(consistencyInfo);
 496         jsonTable.setKeyspaceName(keyspaceName);
 497         jsonTable.setPartitionKey("emp_name");
 498         jsonTable.setClusteringKey("emp_name");
 499         jsonTable.setTableName(tableName);
 500         jsonTable.setFields(fields);
 501         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 502         Response response = data.createTable("1", "1", "1",
 503                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 504                         jsonTable, keyspaceName, tableName);
 505         System.out.println("#######status is " + response.getStatus());
 506         System.out.println("Entity" + response.getEntity());
 507         assertEquals(400, response.getStatus());
 508     }
 509
 510     @Test
 511     public void Test3_createTable3_with_Partition_clusteringKeys() throws Exception {
 512         JsonTable jsonTable = new JsonTable();
 513         Map<String, String> consistencyInfo = new HashMap<>();
 514         Map<String, String> fields = new HashMap<>();
 515         fields.put("uuid", "text");
 516         fields.put("emp_name", "text");
 517         fields.put("emp_salary", "varint");
 518         consistencyInfo.put("type", "eventual");
 519         jsonTable.setConsistencyInfo(consistencyInfo);
 520         jsonTable.setKeyspaceName(keyspaceName);
 521         jsonTable.setPartitionKey("emp_name");
 522         jsonTable.setClusteringKey("uuid");
 523         jsonTable.setTableName(tableName);
 524         jsonTable.setFields(fields);
 525         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 526         Response response = data.createTable("1", "1", "1",
 527                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 528                         jsonTable, keyspaceName, "tableName1");
 529         System.out.println("#######status is " + response.getStatus());
 530         System.out.println("Entity" + response.getEntity());
 531         assertEquals(200, response.getStatus());
 532     }
 533
 534     // Improper parenthesis in key field
 535     @Test
 536     public void Test3_createTable_badParantesis() throws Exception {
 537         String tableNameC ="testTable0";
 538         JsonTable jsonTable = new JsonTable();
 539         Map<String, String> consistencyInfo = new HashMap<>();
 540         Map<String, String> fields = new HashMap<>();
 541         fields.put("uuid", "text");
 542         fields.put("emp_name", "text");
 543         fields.put("emp_salary", "varint");
 544         fields.put("PRIMARY KEY", "(emp_name),emp_id)");
 545         fields.put("emp_id", "varint");
 546         consistencyInfo.put("type", "eventual");
 547         jsonTable.setConsistencyInfo(consistencyInfo);
 548         jsonTable.setKeyspaceName(keyspaceName);
 549         jsonTable.setPrimaryKey("emp_name");
 550         jsonTable.setTableName(tableNameC);
 551         jsonTable.setClusteringOrder("emp_id Desc");
 552         jsonTable.setFields(fields);
 553         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 554         Response response = data.createTable("1", "1", "1",
 555                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 556                         jsonTable, keyspaceName, tableNameC);
 557         System.out.println("#######status is " + response.getStatus());
 558         System.out.println("Entity" + response.getEntity());
 559         //assertEquals(400, response.getStatus());
 560         assertTrue(200 != response.getStatus());
 561     }
 562
 563
 564     // good clustering key
 565     @Test
 566     public void Test3_createTable_1_clusterKey_good() throws Exception {
 567         String tableNameC ="testTableC1";
 568         JsonTable jsonTable = new JsonTable();
 569         Map<String, String> consistencyInfo = new HashMap<>();
 570         Map<String, String> fields = new HashMap<>();
 571         fields.put("uuid", "text");
 572         fields.put("emp_name", "text");
 573         fields.put("emp_salary", "varint");
 574         fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 575         consistencyInfo.put("type", "eventual");
 576         jsonTable.setConsistencyInfo(consistencyInfo);
 577         jsonTable.setKeyspaceName(keyspaceName);
 578        // jsonTable.setPrimaryKey("emp_name");
 579         jsonTable.setTableName(tableNameC);
 580         jsonTable.setClusteringOrder("emp_salary ASC");
 581         jsonTable.setFields(fields);
 582         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 583         Response response = data.createTable("1", "1", "1",
 584                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 585                         jsonTable, keyspaceName, tableNameC);
 586         System.out.println("#######status is " + response.getStatus());
 587         System.out.println("Entity" + response.getEntity());
 588         assertEquals(200, response.getStatus());
 589     }
 590
 591     // bad partition key=clustering key
 592     @Test
 593     public void Test3_createTable_2_clusterKey_bad() throws Exception {
 594         String tableNameC ="testTableC2";
 595         JsonTable jsonTable = new JsonTable();
 596         Map<String, String> consistencyInfo = new HashMap<>();
 597         Map<String, String> fields = new HashMap<>();
 598         fields.put("uuid", "text");
 599         fields.put("emp_name", "text");
 600         fields.put("emp_salary", "varint");
 601         fields.put("PRIMARY KEY", "((emp_name),emp_name)");
 602         consistencyInfo.put("type", "eventual");
 603         jsonTable.setConsistencyInfo(consistencyInfo);
 604         jsonTable.setKeyspaceName(keyspaceName);
 605         jsonTable.setPrimaryKey("emp_name");  // "PRIMARY KEY" overrides if primaryKey present
 606         jsonTable.setTableName(tableNameC);
 607         jsonTable.setClusteringOrder("emp_salary ASC");
 608         jsonTable.setFields(fields);
 609         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 610         Response response = data.createTable("1", "1", "1",
 611                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 612                         jsonTable, keyspaceName, tableNameC);
 613         System.out.println("#######status is " + response.getStatus());
 614         System.out.println("Entity" + response.getEntity());
 615         assertTrue(200 !=response.getStatus());
 616     }
 617
 618     // good composite partition key,clustering key
 619     @Test
 620     public void Test3_createTable_3_partition_clusterKey_good() throws Exception {
 621         String tableNameC ="testTableC3";
 622         JsonTable jsonTable = new JsonTable();
 623         Map<String, String> consistencyInfo = new HashMap<>();
 624         Map<String, String> fields = new HashMap<>();
 625         fields.put("uuid", "text");
 626         fields.put("emp_name", "text");
 627         fields.put("emp_id", "varint");
 628         fields.put("emp_salary", "varint");
 629         fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
 630         consistencyInfo.put("type", "eventual");
 631         jsonTable.setConsistencyInfo(consistencyInfo);
 632         jsonTable.setKeyspaceName(keyspaceName);
 633         jsonTable.setPrimaryKey("emp_name");
 634         jsonTable.setTableName(tableNameC);
 635         jsonTable.setClusteringOrder("emp_salary ASC");
 636         jsonTable.setFields(fields);
 637         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 638         Response response = data.createTable("1", "1", "1",
 639                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 640                         jsonTable, keyspaceName, tableNameC);
 641         System.out.println("#######status is " + response.getStatus());
 642         System.out.println("Entity" + response.getEntity());
 643         assertEquals(200, response.getStatus());
 644     }
 645
 646     // bad - not all cols in order by of composite partition key,clustering key
 647     @Test
 648     public void Test3_createTable_4_clusteringOrder_bad() throws Exception {
 649         String tableNameC ="testTableC4";
 650         JsonTable jsonTable = new JsonTable();
 651         Map<String, String> consistencyInfo = new HashMap<>();
 652         Map<String, String> fields = new HashMap<>();
 653         fields.put("uuid", "text");
 654         fields.put("emp_name", "text");
 655         fields.put("emp_id", "varint");
 656         fields.put("emp_salary", "varint");
 657         fields.put("PRIMARY KEY", "((emp_name),emp_id,emp_salary)");
 658         consistencyInfo.put("type", "eventual");
 659         jsonTable.setConsistencyInfo(consistencyInfo);
 660         jsonTable.setKeyspaceName(keyspaceName);
 661         jsonTable.setPrimaryKey("emp_name");
 662         jsonTable.setTableName(tableNameC);
 663         jsonTable.setClusteringOrder("emp_salary ASC");
 664         jsonTable.setFields(fields);
 665         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 666         Response response = data.createTable("1", "1", "1",
 667                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 668                         jsonTable, keyspaceName, tableNameC);
 669         System.out.println("#######status is " + response.getStatus());
 670         System.out.println("Entity" + response.getEntity());
 671         assertTrue(200 != response.getStatus());
 672     }
 673
 674     // bad - wrong cols in order by of composite partition key,clustering key
 675     @Test
 676     public void Test3_createTable_5_clusteringOrder_bad() throws Exception {
 677         String tableNameC ="testTableC5";
 678         JsonTable jsonTable = new JsonTable();
 679         Map<String, String> consistencyInfo = new HashMap<>();
 680         Map<String, String> fields = new HashMap<>();
 681         fields.put("uuid", "text");
 682         fields.put("emp_name", "text");
 683         fields.put("emp_id", "varint");
 684         fields.put("emp_salary", "varint");
 685         fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
 686         consistencyInfo.put("type", "eventual");
 687         jsonTable.setConsistencyInfo(consistencyInfo);
 688         jsonTable.setKeyspaceName(keyspaceName);
 689         jsonTable.setPrimaryKey("emp_name");
 690         jsonTable.setTableName(tableNameC);
 691         jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
 692         jsonTable.setFields(fields);
 693         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 694         Response response = data.createTable("1", "1", "1",
 695                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 696                         jsonTable, keyspaceName, tableNameC);
 697         System.out.println("#######status is " + response.getStatus());
 698         System.out.println("Entity" + response.getEntity());
 699         assertTrue(200 != response.getStatus());
 700     }
 701
 702     // bad - wrong cols in order by of composite partition key,clustering key
 703     @Test
 704     public void Test3_createTable_6_clusteringOrder_bad() throws Exception {
 705         String tableNameC ="testTableC6";
 706         JsonTable jsonTable = new JsonTable();
 707         Map<String, String> consistencyInfo = new HashMap<>();
 708         Map<String, String> fields = new HashMap<>();
 709         fields.put("uuid", "text");
 710         fields.put("emp_name", "text");
 711         fields.put("emp_id", "varint");
 712         fields.put("emp_salary", "varint");
 713         fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
 714         consistencyInfo.put("type", "eventual");
 715         jsonTable.setConsistencyInfo(consistencyInfo);
 716         jsonTable.setKeyspaceName(keyspaceName);
 717         jsonTable.setPrimaryKey("((uuid,emp_name),emp_id,emp_salary)"); // overridden by
 718         jsonTable.setTableName(tableNameC);
 719         jsonTable.setClusteringOrder("emp_id desc, emp_salary ASC,uuid desc");
 720         jsonTable.setFields(fields);
 721         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 722         Response response = data.createTable("1", "1", "1",
 723                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 724                         jsonTable, keyspaceName, tableNameC);
 725         System.out.println("#######status is " + response.getStatus());
 726         System.out.println("Entity" + response.getEntity());
 727         assertTrue(200 != response.getStatus());
 728     }
 729
 730
 731     @Test
 732     public void Test3_createTableIndex_1() throws Exception {
 733         String tableNameC ="testTableCinx";
 734         JsonTable jsonTable = new JsonTable();
 735         Map<String, String> consistencyInfo = new HashMap<>();
 736         Map<String, String> fields = new HashMap<>();
 737         fields.put("uuid", "text");
 738         fields.put("emp_name", "text");
 739         fields.put("emp_salary", "varint");
 740         fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 741         consistencyInfo.put("type", "eventual");
 742         jsonTable.setConsistencyInfo(consistencyInfo);
 743         jsonTable.setKeyspaceName(keyspaceName);
 744         jsonTable.setTableName(tableNameC);
 745         jsonTable.setClusteringOrder("emp_salary ASC");
 746         jsonTable.setFields(fields);
 747         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 748         Response response = data.createTable("1", "1", "1",
 749                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 750                         jsonTable, keyspaceName, tableNameC);
 751         MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
 752         Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
 753         Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
 754         response = data.createIndex("1", "1", "1",
 755                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 756                  keyspaceName, tableNameC,"uuid",info);
 757         assertEquals(200, response.getStatus());
 758     }
 759
 760     @Test
 761     public void Test3_createTableIndex_badindexname() throws Exception {
 762         String tableNameC ="testTableCinx";
 763         JsonTable jsonTable = new JsonTable();
 764         Map<String, String> consistencyInfo = new HashMap<>();
 765         Map<String, String> fields = new HashMap<>();
 766         fields.put("uuid", "text");
 767         fields.put("emp_name", "text");
 768         fields.put("emp_salary", "varint");
 769         fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 770         consistencyInfo.put("type", "eventual");
 771         jsonTable.setConsistencyInfo(consistencyInfo);
 772         jsonTable.setKeyspaceName(keyspaceName);
 773         jsonTable.setTableName(tableNameC);
 774         jsonTable.setClusteringOrder("emp_salary ASC");
 775         jsonTable.setFields(fields);
 776         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 777         Response response = data.createTable("1", "1", "1",
 778                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 779                         jsonTable, keyspaceName, tableNameC);
 780         MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
 781         Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
 782         Mockito.when(rowParams.getFirst("index_name")).thenReturn("my index");
 783         response = data.createIndex("1", "1", "1",
 784                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 785                  keyspaceName, tableNameC,"uuid",info);
 786         assertEquals(400, response.getStatus());
 787     }
 788
 789     @Test
 790     public void Test3_createTableIndex_wrongindex() throws Exception {
 791         String tableNameC ="testTableCinx";
 792         JsonTable jsonTable = new JsonTable();
 793         Map<String, String> consistencyInfo = new HashMap<>();
 794         Map<String, String> fields = new HashMap<>();
 795         fields.put("uuid", "text");
 796         fields.put("emp_name", "text");
 797         fields.put("emp_salary", "varint");
 798         fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 799         consistencyInfo.put("type", "eventual");
 800         jsonTable.setConsistencyInfo(consistencyInfo);
 801         jsonTable.setKeyspaceName(keyspaceName);
 802         jsonTable.setTableName(tableNameC);
 803         jsonTable.setClusteringOrder("emp_salary ASC");
 804         jsonTable.setFields(fields);
 805         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 806         Response response = data.createTable("1", "1", "1",
 807                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 808                         jsonTable, keyspaceName, tableNameC);
 809         MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
 810         Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
 811         Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
 812         response = data.createIndex("1", "1", "1",
 813                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 814                  keyspaceName, tableNameC,"id",info);
 815         assertEquals(400, response.getStatus());
 816     }
 817
 818     @Test
 819     public void Test4_insertIntoTable() throws Exception {
 820         JsonInsert jsonInsert = new JsonInsert();
 821         Map<String, String> consistencyInfo = new HashMap<>();
 822         Map<String, Object> values = new HashMap<>();
 823         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 824         values.put("emp_name", "testName");
 825         values.put("emp_salary", 500);
 826         consistencyInfo.put("type", "eventual");
 827         jsonInsert.setConsistencyInfo(consistencyInfo);
 828         jsonInsert.setKeyspaceName(keyspaceName);
 829         jsonInsert.setTableName(tableName);
 830         jsonInsert.setValues(values);
 831         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 832         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 833                 appName, authorization, jsonInsert, keyspaceName, tableName);
 834         assertEquals(200, response.getStatus());
 835     }
 836
 837     @Test
 838     public void Test4_insertIntoTable2() throws Exception {
 839         JsonInsert jsonInsert = new JsonInsert();
 840         Map<String, String> consistencyInfo = new HashMap<>();
 841         Map<String, Object> values = new HashMap<>();
 842         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 843         values.put("emp_name", "test1");
 844         values.put("emp_salary", 1500);
 845         consistencyInfo.put("type", "eventual");
 846         jsonInsert.setConsistencyInfo(consistencyInfo);
 847         jsonInsert.setKeyspaceName(keyspaceName);
 848         jsonInsert.setTableName(tableName);
 849         jsonInsert.setValues(values);
 850         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 851         Response response = data.insertIntoTable("1", "1", "1",
 852                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 853                         jsonInsert, keyspaceName, tableName);
 854         assertEquals(200, response.getStatus());
 855     }
 856
 857     // Auth Error
 858     @Test
 859     public void Test4_insertIntoTable3() throws Exception {
 860         JsonInsert jsonInsert = new JsonInsert();
 861         Map<String, String> consistencyInfo = new HashMap<>();
 862         Map<String, Object> values = new HashMap<>();
 863         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 864         values.put("emp_name", "test1");
 865         values.put("emp_salary", 1500);
 866         consistencyInfo.put("type", "eventual");
 867         jsonInsert.setConsistencyInfo(consistencyInfo);
 868         jsonInsert.setKeyspaceName(keyspaceName);
 869         jsonInsert.setTableName(tableName);
 870         jsonInsert.setValues(values);
 871         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 872         Response response = data.insertIntoTable("1", "1", "1",
 873                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
 874                         jsonInsert, keyspaceName, tableName);
 875         assertEquals(401, response.getStatus());
 876     }
 877
 878     // Table wrong
 879     @Test
 880     public void Test4_insertIntoTable4() throws Exception {
 881         JsonInsert jsonInsert = new JsonInsert();
 882         Map<String, String> consistencyInfo = new HashMap<>();
 883         Map<String, Object> values = new HashMap<>();
 884         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 885         values.put("emp_name", "test1");
 886         values.put("emp_salary", 1500);
 887         consistencyInfo.put("type", "eventual");
 888         jsonInsert.setConsistencyInfo(consistencyInfo);
 889         jsonInsert.setKeyspaceName(keyspaceName);
 890         jsonInsert.setTableName(tableName);
 891         jsonInsert.setValues(values);
 892         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 893         Response response = data.insertIntoTable("1", "1", "1",
 894                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 895                         jsonInsert, keyspaceName, "wrong");
 896         assertEquals(400, response.getStatus());
 897     }
 898
 899     @Test
 900     public void Test4_insertIntoTable5() throws Exception {
 901         JsonInsert jsonInsert = new JsonInsert();
 902         Map<String, String> consistencyInfo = new HashMap<>();
 903         Map<String, Object> values = new HashMap<>();
 904         values.put("id", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 905         values.put("emp_name", "test1");
 906         values.put("emp_salary", 1500);
 907         consistencyInfo.put("type", "eventual");
 908         jsonInsert.setConsistencyInfo(consistencyInfo);
 909         jsonInsert.setKeyspaceName(keyspaceName);
 910         jsonInsert.setTableName(tableName);
 911         jsonInsert.setValues(values);
 912         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 913         Response response = data.insertIntoTable("1", "1", "1",
 914                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 915                         jsonInsert, keyspaceName, tableName);
 916         assertEquals(400, response.getStatus());
 917     }
 918
 919     @Test
 920     public void Test4_insertIntoTable6() throws Exception {
 921         JsonInsert jsonInsert = new JsonInsert();
 922         Map<String, String> consistencyInfo = new HashMap<>();
 923         Map<String, Object> values = new HashMap<>();
 924         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 925         values.put("emp_salary", 1500);
 926         consistencyInfo.put("type", "eventual");
 927         jsonInsert.setConsistencyInfo(consistencyInfo);
 928         jsonInsert.setKeyspaceName(keyspaceName);
 929         jsonInsert.setTableName(tableName);
 930         jsonInsert.setValues(values);
 931         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 932         Response response = data.insertIntoTable("1", "1", "1",
 933                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 934                         jsonInsert, keyspaceName, tableName);
 935         assertEquals(400, response.getStatus());
 936     }
 937
 938     @Test
 939     public void Test4_insertIntoTable7() throws Exception {
 940         JsonInsert jsonInsert = new JsonInsert();
 941         Map<String, String> consistencyInfo = new HashMap<>();
 942         Map<String, Object> values = new HashMap<>();
 943         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 944         values.put("emp_name", "test2");
 945         values.put("emp_salary", 1500);
 946         consistencyInfo.put("type", "eventual");
 947         jsonInsert.setConsistencyInfo(consistencyInfo);
 948         jsonInsert.setKeyspaceName(keyspaceName);
 949         jsonInsert.setTableName(tableName);
 950         jsonInsert.setValues(values);
 951         jsonInsert.setTtl("1000");
 952         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 953         Response response = data.insertIntoTable("1", "1", "1",
 954                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 955                         jsonInsert, keyspaceName, tableName);
 956         assertEquals(200, response.getStatus());
 957     }
 958
 959     @Test
 960     public void Test4_insertIntoTable8() throws Exception {
 961         JsonInsert jsonInsert = new JsonInsert();
 962         Map<String, String> consistencyInfo = new HashMap<>();
 963         Map<String, Object> values = new HashMap<>();
 964         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 965         values.put("emp_name", "test3");
 966         values.put("emp_salary", 1500);
 967         consistencyInfo.put("type", "eventual");
 968         jsonInsert.setConsistencyInfo(consistencyInfo);
 969         jsonInsert.setKeyspaceName(keyspaceName);
 970         jsonInsert.setTableName(tableName);
 971         jsonInsert.setValues(values);
 972         jsonInsert.setTimestamp("15000");
 973         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 974         Response response = data.insertIntoTable("1", "1", "1",
 975                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 976                         jsonInsert, keyspaceName, tableName);
 977         assertEquals(200, response.getStatus());
 978     }
 979
 980     @Test
 981     public void Test4_insertIntoTable9() throws Exception {
 982         JsonInsert jsonInsert = new JsonInsert();
 983         Map<String, String> consistencyInfo = new HashMap<>();
 984         Map<String, Object> values = new HashMap<>();
 985         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 986         values.put("emp_name", "test4");
 987         values.put("emp_salary", 1500);
 988         consistencyInfo.put("type", "eventual");
 989         jsonInsert.setConsistencyInfo(consistencyInfo);
 990         jsonInsert.setKeyspaceName(keyspaceName);
 991         jsonInsert.setTableName(tableName);
 992         jsonInsert.setValues(values);
 993         jsonInsert.setTtl("1000");
 994         jsonInsert.setTimestamp("15000");
 995         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 996         Response response = data.insertIntoTable("1", "1", "1",
 997                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 998                         jsonInsert, keyspaceName, tableName);
 999         assertEquals(200, response.getStatus());
1000     }
1001
1002     @Test
1003     public void Test4_insertIntoTable10() throws Exception {
1004         JsonInsert jsonInsert = new JsonInsert();
1005         Map<String, String> consistencyInfo = new HashMap<>();
1006         Map<String, Object> values = new HashMap<>();
1007         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1008         values.put("emp_name", "test5");
1009         values.put("emp_salary", 1500);
1010         consistencyInfo.put("type", "critical");
1011         jsonInsert.setConsistencyInfo(consistencyInfo);
1012         jsonInsert.setKeyspaceName(keyspaceName);
1013         jsonInsert.setTableName(tableName);
1014         jsonInsert.setValues(values);
1015         jsonInsert.setTtl("1000");
1016         jsonInsert.setTimestamp("15000");
1017         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1018         Response response = data.insertIntoTable("1", "1", "1",
1019                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1020                         jsonInsert, keyspaceName, tableName);
1021         assertEquals(400, response.getStatus());
1022     }
1023
1024     @Test
1025     public void Test4_insertIntoTable11() throws Exception {
1026         JsonInsert jsonInsert = new JsonInsert();
1027         Map<String, String> consistencyInfo = new HashMap<>();
1028         Map<String, Object> values = new HashMap<>();
1029         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1030         values.put("emp_name", "test6");
1031         values.put("emp_salary", 1500);
1032         consistencyInfo.put("type", "atomic_delete_lock");
1033         jsonInsert.setConsistencyInfo(consistencyInfo);
1034         jsonInsert.setKeyspaceName(keyspaceName);
1035         jsonInsert.setTableName(tableName);
1036         jsonInsert.setValues(values);
1037         jsonInsert.setTtl("1000");
1038         jsonInsert.setTimestamp("15000");
1039         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1040         Response response = data.insertIntoTable("1", "1", "1",
1041                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1042                         jsonInsert, keyspaceName, tableName);
1043         assertEquals(200, response.getStatus());
1044     }
1045
1046     @Test
1047     public void Test4_insertIntoTable12() throws Exception {
1048         JsonInsert jsonInsert = new JsonInsert();
1049         Map<String, String> consistencyInfo = new HashMap<>();
1050         Map<String, Object> values = new HashMap<>();
1051         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1052         values.put("emp_name", "test7");
1053         values.put("emp_salary", 1500);
1054         consistencyInfo.put("type", "atomic");
1055         jsonInsert.setConsistencyInfo(consistencyInfo);
1056         jsonInsert.setKeyspaceName(keyspaceName);
1057         jsonInsert.setTableName(tableName);
1058         jsonInsert.setValues(values);
1059         jsonInsert.setTtl("1000");
1060         jsonInsert.setTimestamp("15000");
1061         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1062         Response response = data.insertIntoTable("1", "1", "1",
1063                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1064                         jsonInsert, keyspaceName, tableName);
1065         assertEquals(200, response.getStatus());
1066     }
1067
1068     @Test
1069     public void Test5_updateTable() throws Exception {
1070         JsonUpdate jsonUpdate = new JsonUpdate();
1071         Map<String, String> consistencyInfo = new HashMap<>();
1072         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1073         Map<String, Object> values = new HashMap<>();
1074         row.add("emp_name", "testName");
1075         values.put("emp_salary", 2500);
1076         consistencyInfo.put("type", "atomic");
1077         jsonUpdate.setConsistencyInfo(consistencyInfo);
1078         jsonUpdate.setKeyspaceName(keyspaceName);
1079         jsonUpdate.setTableName(tableName);
1080         jsonUpdate.setValues(values);
1081         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1082         Mockito.when(info.getQueryParameters()).thenReturn(row);
1083         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1084                 authorization, jsonUpdate, keyspaceName, tableName, info);
1085         assertEquals(200, response.getStatus());
1086     }
1087
1088     // need mock code to create error for MusicCore methods
1089     @Test
1090     public void Test5_updateTableAuthE() throws Exception {
1091       MockitoAnnotations.initMocks(this);
1092         JsonUpdate jsonUpdate = new JsonUpdate();
1093         Map<String, String> consistencyInfo = new HashMap<>();
1094         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1095         Map<String, Object> values = new HashMap<>();
1096         row.add("emp_name", "testName");
1097         values.put("emp_salary", 2500);
1098         consistencyInfo.put("type", "atomic");
1099         jsonUpdate.setConsistencyInfo(consistencyInfo);
1100         jsonUpdate.setKeyspaceName(keyspaceName);
1101         jsonUpdate.setTableName(tableName);
1102         jsonUpdate.setValues(values);
1103         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1104         Mockito.when(info.getQueryParameters()).thenReturn(row);
1105         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1106                 authorization, jsonUpdate, keyspaceName, tableName, info);
1107         assertEquals(200, response.getStatus());
1108     }
1109
1110     @Test
1111     public void Test5_updateTableAuthException1() throws Exception {
1112         JsonUpdate jsonUpdate = new JsonUpdate();
1113         Map<String, String> consistencyInfo = new HashMap<>();
1114         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1115         Map<String, Object> values = new HashMap<>();
1116         row.add("emp_name", "testName");
1117         values.put("emp_salary", 2500);
1118         consistencyInfo.put("type", "atomic");
1119         jsonUpdate.setConsistencyInfo(consistencyInfo);
1120         jsonUpdate.setKeyspaceName(keyspaceName);
1121         jsonUpdate.setTableName(tableName);
1122         jsonUpdate.setValues(values);
1123         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1124         Mockito.when(info.getQueryParameters()).thenReturn(row);
1125         String authDatax = ":";//+password;
1126         String authorizationx = new String(Base64.encode(authDatax.getBytes()));
1127         try {
1128         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1129                 authorizationx, jsonUpdate, keyspaceName, tableName, info);
1130               assertEquals(200, response.getStatus());
1131         } catch(RuntimeException e) {
1132            System.out.println("Update table Runtime exception="+e);
1133         }
1134     }
1135
1136     @Test
1137     public void Test5_updateTableAuthEmpty() throws Exception {
1138         JsonUpdate jsonUpdate = new JsonUpdate();
1139         Map<String, String> consistencyInfo = new HashMap<>();
1140         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1141         Map<String, Object> values = new HashMap<>();
1142         row.add("emp_name", "testName");
1143         values.put("emp_salary", 2500);
1144         consistencyInfo.put("type", "atomic");
1145         jsonUpdate.setConsistencyInfo(consistencyInfo);
1146         jsonUpdate.setKeyspaceName(keyspaceName);
1147         jsonUpdate.setTableName(tableName);
1148         jsonUpdate.setValues(values);
1149         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1150         Mockito.when(info.getQueryParameters()).thenReturn(row);
1151         String authDatax =":"+password;
1152         String authorizationx = new String(Base64.encode(authDatax.getBytes()));
1153         String appNamex="xx";
1154         try {
1155             // Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1156                Response response = data.updateTable("1", "1", "1", "", appNamex,
1157                 authorizationx, jsonUpdate, keyspaceName, tableName, info);
1158               assertEquals(200, response.getStatus());
1159         } catch(RuntimeException e) {
1160            System.out.println("Update table Runtime exception="+e);
1161         }
1162     }
1163
1164     @Test
1165     public void Test5_updateTable_wrongauth() throws Exception {
1166         JsonUpdate jsonUpdate = new JsonUpdate();
1167         Map<String, String> consistencyInfo = new HashMap<>();
1168         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1169         Map<String, Object> values = new HashMap<>();
1170         row.add("emp_name", "testName");
1171         values.put("emp_salary", 2500);
1172         consistencyInfo.put("type", "atomic");
1173         jsonUpdate.setConsistencyInfo(consistencyInfo);
1174         jsonUpdate.setKeyspaceName(keyspaceName);
1175         jsonUpdate.setTableName(tableName);
1176         jsonUpdate.setValues(values);
1177         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1178         Mockito.when(info.getQueryParameters()).thenReturn(row);
1179         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1180                 wrongAuthorization, jsonUpdate, keyspaceName, tableName, info);
1181         assertEquals(401, response.getStatus());
1182     }
1183
1184     @Test
1185     public void Test5_updateTable_invalidColumn() throws Exception {
1186         JsonUpdate jsonUpdate = new JsonUpdate();
1187         Map<String, String> consistencyInfo = new HashMap<>();
1188         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1189         Map<String, Object> values = new HashMap<>();
1190         row.add("id", "testName");
1191         values.put("emp_salary", 2500);
1192         consistencyInfo.put("type", "atomic");
1193         jsonUpdate.setConsistencyInfo(consistencyInfo);
1194         jsonUpdate.setKeyspaceName(keyspaceName);
1195         jsonUpdate.setTableName(tableName);
1196         jsonUpdate.setValues(values);
1197         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1198         Mockito.when(info.getQueryParameters()).thenReturn(row);
1199         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1200                 authorization, jsonUpdate, keyspaceName, tableName, info);
1201         assertEquals(400, response.getStatus());
1202     }
1203
1204     @Test
1205     public void Test5_updateTable_ttl() throws Exception {
1206         JsonUpdate jsonUpdate = new JsonUpdate();
1207         Map<String, String> consistencyInfo = new HashMap<>();
1208         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1209         Map<String, Object> values = new HashMap<>();
1210         row.add("emp_name", "testName8");
1211         values.put("emp_salary", 2500);
1212         consistencyInfo.put("type", "atomic");
1213         jsonUpdate.setConsistencyInfo(consistencyInfo);
1214         jsonUpdate.setKeyspaceName(keyspaceName);
1215         jsonUpdate.setTableName(tableName);
1216         jsonUpdate.setValues(values);
1217         jsonUpdate.setTtl("1000");
1218         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1219         Mockito.when(info.getQueryParameters()).thenReturn(row);
1220         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1221                 authorization, jsonUpdate, keyspaceName, tableName, info);
1222         assertEquals(400, response.getStatus());
1223     }
1224
1225     @Test
1226     public void Test5_updateTable_timsetamp() throws Exception {
1227         JsonUpdate jsonUpdate = new JsonUpdate();
1228         Map<String, String> consistencyInfo = new HashMap<>();
1229         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1230         Map<String, Object> values = new HashMap<>();
1231         row.add("emp_name", "testName9");
1232         values.put("emp_salary", 2500);
1233         consistencyInfo.put("type", "atomic");
1234         jsonUpdate.setConsistencyInfo(consistencyInfo);
1235         jsonUpdate.setKeyspaceName(keyspaceName);
1236         jsonUpdate.setTableName(tableName);
1237         jsonUpdate.setValues(values);
1238         jsonUpdate.setTimestamp("15000");
1239         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1240         Mockito.when(info.getQueryParameters()).thenReturn(row);
1241         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1242                 authorization, jsonUpdate, keyspaceName, tableName, info);
1243         assertEquals(400, response.getStatus());
1244     }
1245
1246     @Test
1247     public void Test5_updateTable_ttl_timestamp() throws Exception {
1248         JsonUpdate jsonUpdate = new JsonUpdate();
1249         Map<String, String> consistencyInfo = new HashMap<>();
1250         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1251         Map<String, Object> values = new HashMap<>();
1252         row.add("emp_name", "testName10");
1253         values.put("emp_salary", 2500);
1254         consistencyInfo.put("type", "atomic");
1255         jsonUpdate.setConsistencyInfo(consistencyInfo);
1256         jsonUpdate.setKeyspaceName(keyspaceName);
1257         jsonUpdate.setTableName(tableName);
1258         jsonUpdate.setValues(values);
1259         jsonUpdate.setTtl("1000");
1260         jsonUpdate.setTimestamp("15000");
1261         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1262         Mockito.when(info.getQueryParameters()).thenReturn(row);
1263         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1264                 authorization, jsonUpdate, keyspaceName, tableName, info);
1265         assertEquals(400, response.getStatus());
1266     }
1267
1268     @Test
1269     public void Test5_updateTable_rowIdEmpty() throws Exception {
1270         JsonUpdate jsonUpdate = new JsonUpdate();
1271         Map<String, String> consistencyInfo = new HashMap<>();
1272         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1273         Map<String, Object> values = new HashMap<>();
1274         //row.add("emp_name", "testName3");
1275         values.put("emp_salary", 2500);
1276         consistencyInfo.put("type", "atomic");
1277         jsonUpdate.setConsistencyInfo(consistencyInfo);
1278         jsonUpdate.setKeyspaceName(keyspaceName);
1279         jsonUpdate.setTableName(tableName);
1280         jsonUpdate.setValues(values);
1281         jsonUpdate.setTtl("1000");
1282         jsonUpdate.setTimestamp("15000");
1283         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1284         Mockito.when(info.getQueryParameters()).thenReturn(row);
1285         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1286                 authorization, jsonUpdate, keyspaceName, tableName, info);
1287         assertEquals(400, response.getStatus());
1288     }
1289
1290     @Test
1291     public void Test5_updateTable_conditions() throws Exception {
1292         JsonUpdate jsonUpdate = new JsonUpdate();
1293         Map<String, String> consistencyInfo = new HashMap<>();
1294         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1295         Map<String, Object> values = new HashMap<>();
1296         Map<String, Object> conditions =  new HashMap<>();
1297         conditions.put("emp_name","testName3");
1298         row.add("emp_name", "testName3");
1299         values.put("emp_salary", 2500);
1300         consistencyInfo.put("type", "atomic");
1301         jsonUpdate.setConsistencyInfo(consistencyInfo);
1302         jsonUpdate.setKeyspaceName(keyspaceName);
1303         jsonUpdate.setTableName(tableName);
1304         jsonUpdate.setValues(values);
1305         jsonUpdate.setConditions(conditions);
1306         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1307         Mockito.when(info.getQueryParameters()).thenReturn(row);
1308         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1309                 authorization, jsonUpdate, keyspaceName, tableName, info);
1310         assertEquals(400, response.getStatus());
1311     }
1312
1313     @Test
1314     public void Test5_updateTable_eventual() throws Exception {
1315         JsonUpdate jsonUpdate = new JsonUpdate();
1316         Map<String, String> consistencyInfo = new HashMap<>();
1317         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1318         Map<String, Object> values = new HashMap<>();
1319         row.add("emp_name", "testName");
1320         values.put("emp_salary", 2500);
1321         consistencyInfo.put("type", "eventual");
1322         jsonUpdate.setConsistencyInfo(consistencyInfo);
1323         jsonUpdate.setKeyspaceName(keyspaceName);
1324         jsonUpdate.setTableName(tableName);
1325         jsonUpdate.setValues(values);
1326         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1327         Mockito.when(info.getQueryParameters()).thenReturn(row);
1328         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1329                 authorization, jsonUpdate, keyspaceName, tableName, info);
1330         assertEquals(200, response.getStatus());
1331     }
1332
1333     @Test
1334     public void Test5_updateTable_critical() throws Exception {
1335         JsonUpdate jsonUpdate = new JsonUpdate();
1336         Map<String, String> consistencyInfo = new HashMap<>();
1337         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1338         Map<String, Object> values = new HashMap<>();
1339         row.add("emp_name", "testName");
1340         values.put("emp_salary", 2500);
1341         consistencyInfo.put("type", "critical");
1342         jsonUpdate.setConsistencyInfo(consistencyInfo);
1343         jsonUpdate.setKeyspaceName(keyspaceName);
1344         jsonUpdate.setTableName(tableName);
1345         jsonUpdate.setValues(values);
1346         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1347         Mockito.when(info.getQueryParameters()).thenReturn(row);
1348         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1349                 authorization, jsonUpdate, keyspaceName, tableName, info);
1350         assertEquals(400, response.getStatus());
1351     }
1352
1353     @Test
1354     public void Test5_updateTable_atomic_delete_lock() throws Exception {
1355         JsonUpdate jsonUpdate = new JsonUpdate();
1356         Map<String, String> consistencyInfo = new HashMap<>();
1357         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1358         Map<String, Object> values = new HashMap<>();
1359         row.add("emp_name", "testName");
1360         values.put("emp_salary", 2500);
1361         consistencyInfo.put("type", "atomic_delete_lock");
1362         jsonUpdate.setConsistencyInfo(consistencyInfo);
1363         jsonUpdate.setKeyspaceName(keyspaceName);
1364         jsonUpdate.setTableName(tableName);
1365         jsonUpdate.setValues(values);
1366         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1367         Mockito.when(info.getQueryParameters()).thenReturn(row);
1368         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1369                 authorization, jsonUpdate, keyspaceName, tableName, info);
1370         assertEquals(200, response.getStatus());
1371     }
1372
1373     @Test
1374     public void Test6_select() throws Exception {
1375         JsonSelect jsonSelect = new JsonSelect();
1376         Map<String, String> consistencyInfo = new HashMap<>();
1377         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1378         row.add("emp_name", "testName");
1379         consistencyInfo.put("type", "atomic");
1380         jsonSelect.setConsistencyInfo(consistencyInfo);
1381         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1382         Mockito.when(info.getQueryParameters()).thenReturn(row);
1383         Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1384                         appName, authorization, keyspaceName, tableName, info);
1385         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
1386         HashMap<String, Object> result = map.get("result");
1387         assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
1388     }
1389
1390     @Test
1391     public void Test6_select_withException() throws Exception {
1392         JsonSelect jsonSelect = new JsonSelect();
1393         Map<String, String> consistencyInfo = new HashMap<>();
1394         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1395         row.add("emp_name", "testName");
1396         consistencyInfo.put("type", "atomic");
1397         jsonSelect.setConsistencyInfo(consistencyInfo);
1398         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1399         Mockito.when(info.getQueryParameters()).thenReturn(row);
1400         RestMusicDataAPI spyData = Mockito.spy(RestMusicDataAPI.class);
1401         Mockito.doThrow(MusicServiceException.class).when(spyData).selectSpecificQuery("v2", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password, keyspaceName, tableName, info, -1);
1402         Response response = spyData.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1403                         appName, authorization, keyspaceName, tableName, info);
1404         assertEquals(400, response.getStatus());
1405     }
1406
1407     @Test
1408     public void Test6_select_nodata() throws Exception {
1409         JsonSelect jsonSelect = new JsonSelect();
1410         Map<String, String> consistencyInfo = new HashMap<>();
1411         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1412         row.add("emp_name", "testName12");
1413         consistencyInfo.put("type", "atomic");
1414         jsonSelect.setConsistencyInfo(consistencyInfo);
1415         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1416         Mockito.when(info.getQueryParameters()).thenReturn(row);
1417         Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1418                         appName, authorization, keyspaceName, tableName, info);
1419         assertEquals(200, response.getStatus());
1420     }
1421
1422     @Test
1423     public void Test6_selectCritical() throws Exception {
1424         JsonInsert jsonInsert = new JsonInsert();
1425         Map<String, String> consistencyInfo = new HashMap<>();
1426         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1427         row.add("emp_name", "testName");
1428         consistencyInfo.put("type", "atomic");
1429         jsonInsert.setConsistencyInfo(consistencyInfo);
1430         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1431         Mockito.when(info.getQueryParameters()).thenReturn(row);
1432         Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1433                         appName, authorization, jsonInsert, keyspaceName, tableName,info);
1434         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
1435         HashMap<String, Object> result = map.get("result");
1436         assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
1437     }
1438
1439     @Test
1440     public void Test6_selectCritical_without_lockID() throws Exception {
1441         JsonInsert jsonInsert = new JsonInsert();
1442         Map<String, String> consistencyInfo = new HashMap<>();
1443         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1444         row.add("emp_name", "testName");
1445         consistencyInfo.put("type", "critical");
1446         jsonInsert.setConsistencyInfo(consistencyInfo);
1447         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1448         Mockito.when(info.getQueryParameters()).thenReturn(row);
1449         Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1450                         appName, authorization, jsonInsert, keyspaceName, tableName,info);
1451         assertEquals(400, response.getStatus());
1452     }
1453
1454     @Test
1455     public void Test6_selectCritical_with_atomic_delete_lock() throws Exception {
1456         JsonInsert jsonInsert = new JsonInsert();
1457         Map<String, String> consistencyInfo = new HashMap<>();
1458         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1459         row.add("emp_name", "testName");
1460         consistencyInfo.put("type", "atomic_delete_lock");
1461         jsonInsert.setConsistencyInfo(consistencyInfo);
1462         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1463         Mockito.when(info.getQueryParameters()).thenReturn(row);
1464         Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1465                         appName, authorization, jsonInsert, keyspaceName, tableName,info);
1466         assertEquals(200, response.getStatus());
1467     }
1468
1469     @Test
1470     public void Test6_selectCritical_with_nodata() throws Exception {
1471         JsonInsert jsonInsert = new JsonInsert();
1472         Map<String, String> consistencyInfo = new HashMap<>();
1473         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1474         row.add("emp_name", "testName12");
1475         consistencyInfo.put("type", "atomic_delete_lock");
1476         jsonInsert.setConsistencyInfo(consistencyInfo);
1477         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1478         Mockito.when(info.getQueryParameters()).thenReturn(row);
1479         Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1480                         appName, authorization, jsonInsert, keyspaceName, tableName,info);
1481         assertEquals(200, response.getStatus());
1482     }
1483
1484     @Test
1485     public void Test6_select_all() throws Exception {
1486         JsonSelect jsonSelect = new JsonSelect();
1487         Map<String, String> consistencyInfo = new HashMap<>();
1488         MultivaluedMap<String, String> row = new MultivaluedMapImpl();;
1489         consistencyInfo.put("type", "atomic");
1490         jsonSelect.setConsistencyInfo(consistencyInfo);
1491         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1492         Mockito.when(info.getQueryParameters()).thenReturn(row);
1493         Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1494                         appName, authorization, keyspaceName, tableName, info);
1495         assertEquals(200, response.getStatus());
1496     }
1497
1498     @Test
1499     public void Test6_deleteFromTable() throws Exception {
1500         JsonDelete jsonDelete = new JsonDelete();
1501         Map<String, String> consistencyInfo = new HashMap<>();
1502         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1503         row.add("emp_name", "test1");
1504         consistencyInfo.put("type", "atomic");
1505         jsonDelete.setConsistencyInfo(consistencyInfo);
1506         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1507         Mockito.when(info.getQueryParameters()).thenReturn(row);
1508         Response response = data.deleteFromTable("1", "1", "1",
1509                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1510                         jsonDelete, keyspaceName, tableName, info);
1511         assertEquals(200, response.getStatus());
1512     }
1513
1514     // Values
1515     @Test
1516     public void Test6_deleteFromTable1() throws Exception {
1517         JsonDelete jsonDelete = new JsonDelete();
1518         Map<String, String> consistencyInfo = new HashMap<>();
1519         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1520         consistencyInfo.put("type", "atomic");
1521         jsonDelete.setConsistencyInfo(consistencyInfo);
1522         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1523         Mockito.when(info.getQueryParameters()).thenReturn(row);
1524         Response response = data.deleteFromTable("1", "1", "1",
1525                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1526                         jsonDelete, keyspaceName, tableName, info);
1527         assertEquals(400, response.getStatus());
1528     }
1529
1530     // delObj
1531     @Test
1532     public void Test6_deleteFromTable2() throws Exception {
1533         JsonDelete jsonDelete = new JsonDelete();
1534         Map<String, String> consistencyInfo = new HashMap<>();
1535         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1536         row.add("emp_name", "test1");
1537         consistencyInfo.put("type", "atomic");
1538         jsonDelete.setConsistencyInfo(consistencyInfo);
1539         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1540         Mockito.when(info.getQueryParameters()).thenReturn(row);
1541         Response response = data.deleteFromTable("1", "1", "1",
1542                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1543                         null, keyspaceName, tableName, info);
1544         assertEquals(400, response.getStatus());
1545     }
1546
1547     @Test
1548     public void Test6_deleteFromTable_columns() throws Exception {
1549         JsonDelete jsonDelete = new JsonDelete();
1550         Map<String, String> consistencyInfo = new HashMap<>();
1551         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1552         row.add("emp_name", "test1");
1553         consistencyInfo.put("type", "atomic");
1554         jsonDelete.setConsistencyInfo(consistencyInfo);
1555         ArrayList<String> columns = new ArrayList<>();
1556         columns.add("uuid");
1557         jsonDelete.setColumns(columns);
1558         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1559         Mockito.when(info.getQueryParameters()).thenReturn(row);
1560         Response response = data.deleteFromTable("1", "1", "1",
1561                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1562                         jsonDelete, keyspaceName, tableName, info);
1563         assertEquals(200, response.getStatus());
1564     }
1565
1566     @Test
1567     public void Test6_deleteFromTable_conditions() throws Exception {
1568         JsonDelete jsonDelete = new JsonDelete();
1569         Map<String, String> consistencyInfo = new HashMap<>();
1570         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1571         Map<String, Object> conditions =  new HashMap<>();
1572         conditions.put("emp_name","testName3");
1573         row.add("emp_name", "test1");
1574         consistencyInfo.put("type", "atomic");
1575         jsonDelete.setConsistencyInfo(consistencyInfo);
1576         ArrayList<String> columns = new ArrayList<>();
1577         jsonDelete.setConditions(conditions);
1578         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1579         Mockito.when(info.getQueryParameters()).thenReturn(row);
1580         Response response = data.deleteFromTable("1", "1", "1",
1581                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1582                         jsonDelete, keyspaceName, tableName, info);
1583         assertEquals(400, response.getStatus());
1584     }
1585
1586     @Test
1587     public void Test6_deleteFromTable_eventual() throws Exception {
1588         JsonDelete jsonDelete = new JsonDelete();
1589         Map<String, String> consistencyInfo = new HashMap<>();
1590         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1591         row.add("emp_name", "test2");
1592         consistencyInfo.put("type", "eventual");
1593         jsonDelete.setConsistencyInfo(consistencyInfo);
1594         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1595         Mockito.when(info.getQueryParameters()).thenReturn(row);
1596         Response response = data.deleteFromTable("1", "1", "1",
1597                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1598                         jsonDelete, keyspaceName, tableName, info);
1599         assertEquals(200, response.getStatus());
1600     }
1601
1602     @Test
1603     public void Test6_deleteFromTable_critical() throws Exception {
1604         JsonDelete jsonDelete = new JsonDelete();
1605         Map<String, String> consistencyInfo = new HashMap<>();
1606         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1607         row.add("emp_name", "test2");
1608         consistencyInfo.put("type", "critical");
1609         jsonDelete.setConsistencyInfo(consistencyInfo);
1610         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1611         Mockito.when(info.getQueryParameters()).thenReturn(row);
1612         Response response = data.deleteFromTable("1", "1", "1",
1613                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1614                         jsonDelete, keyspaceName, tableName, info);
1615         assertEquals(400, response.getStatus());
1616     }
1617
1618     @Test
1619     public void Test6_deleteFromTable_atomic_delete_lock() throws Exception {
1620         JsonDelete jsonDelete = new JsonDelete();
1621         Map<String, String> consistencyInfo = new HashMap<>();
1622         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1623         row.add("emp_name", "test3");
1624         consistencyInfo.put("type", "atomic_delete_lock");
1625         jsonDelete.setConsistencyInfo(consistencyInfo);
1626         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1627         Mockito.when(info.getQueryParameters()).thenReturn(row);
1628         Response response = data.deleteFromTable("1", "1", "1",
1629                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1630                         jsonDelete, keyspaceName, tableName, info);
1631         assertEquals(200, response.getStatus());
1632     }
1633
1634     @Test
1635     public void Test7_dropTable() throws Exception {
1636         JsonTable jsonTable = new JsonTable();
1637         Map<String, String> consistencyInfo = new HashMap<>();
1638         consistencyInfo.put("type", "atomic");
1639         jsonTable.setConsistencyInfo(consistencyInfo);
1640         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1641         Response response = data.dropTable("1", "1", "1",
1642                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1643                          keyspaceName, tableName);
1644         assertEquals(200, response.getStatus());
1645     }
1646
1647
1648     @Test
1649     public void Test8_deleteKeyspace() throws Exception {
1650         JsonKeySpace jsonKeyspace = new JsonKeySpace();
1651         Map<String, String> consistencyInfo = new HashMap<>();
1652         Map<String, Object> replicationInfo = new HashMap<>();
1653         consistencyInfo.put("type", "eventual");
1654         replicationInfo.put("class", "SimpleStrategy");
1655         replicationInfo.put("replication_factor", 1);
1656         jsonKeyspace.setConsistencyInfo(consistencyInfo);
1657         jsonKeyspace.setDurabilityOfWrites("true");
1658         jsonKeyspace.setKeyspaceName("TestApp1");
1659         jsonKeyspace.setReplicationInfo(replicationInfo);
1660         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1661         Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1662                         authorization,appName,  keyspaceName);
1663         assertEquals(200, response.getStatus());
1664     }
1665
1666     @Test
1667     public void Test8_deleteKeyspace1() throws Exception {
1668         JsonKeySpace jsonKeyspace = new JsonKeySpace();
1669         Map<String, String> consistencyInfo = new HashMap<>();
1670         Map<String, Object> replicationInfo = new HashMap<>();
1671         consistencyInfo.put("type", "eventual");
1672         replicationInfo.put("class", "SimpleStrategy");
1673         replicationInfo.put("replication_factor", 1);
1674         jsonKeyspace.setConsistencyInfo(consistencyInfo);
1675         jsonKeyspace.setDurabilityOfWrites("true");
1676         jsonKeyspace.setKeyspaceName("TestApp1");
1677         jsonKeyspace.setReplicationInfo(replicationInfo);
1678         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1679         Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1680                 authorization,appName,  "keyspaceName");
1681         assertEquals(200, response.getStatus());
1682     }
1683
1684     @Test
1685     public void Test8_deleteKeyspace2() throws Exception {
1686         JsonKeySpace jsonKeyspace = new JsonKeySpace();
1687         Map<String, String> consistencyInfo = new HashMap<>();
1688         Map<String, Object> replicationInfo = new HashMap<>();
1689         consistencyInfo.put("type", "eventual");
1690         replicationInfo.put("class", "SimpleStrategy");
1691         replicationInfo.put("replication_factor", 1);
1692         jsonKeyspace.setConsistencyInfo(consistencyInfo);
1693         jsonKeyspace.setDurabilityOfWrites("true");
1694         jsonKeyspace.setKeyspaceName("TestApp1");
1695         jsonKeyspace.setReplicationInfo(replicationInfo);
1696         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1697         Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1698                 wrongAuthorization, appName, keyspaceName);
1699         assertEquals(401, response.getStatus());
1700     }
1701
1702     @Test
1703     public void Test6_onboard() throws Exception {
1704         JsonOnboard jsonOnboard = new JsonOnboard();
1705         jsonOnboard.setAppname("TestApp2");
1706         jsonOnboard.setIsAAF("false");
1707         jsonOnboard.setUserId("TestUser2");
1708         jsonOnboard.setPassword("TestPassword2");
1709         Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
1710         resultMap.containsKey("success");
1711         onboardUUID = resultMap.get("Generated AID").toString();
1712         assertEquals("Your application TestApp2 has been onboarded with MUSIC.", resultMap.get("Success"));
1713     }
1714
1715     @Test
1716     public void Test6_onboard_duplicate() throws Exception {
1717         JsonOnboard jsonOnboard = new JsonOnboard();
1718         jsonOnboard.setAppname("TestApp2");
1719         jsonOnboard.setIsAAF("false");
1720         jsonOnboard.setUserId("TestUser2");
1721         jsonOnboard.setPassword("TestPassword2");
1722         Response response = admin.onboardAppWithMusic(jsonOnboard);
1723         assertEquals(400, response.getStatus());
1724     }
1725
1726     // Missing appname
1727     @Test
1728     public void Test6_onboard1() throws Exception {
1729         JsonOnboard jsonOnboard = new JsonOnboard();
1730         jsonOnboard.setIsAAF("false");
1731         jsonOnboard.setUserId("TestUser2");
1732         jsonOnboard.setPassword("TestPassword2");
1733         Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
1734         resultMap.containsKey("success");
1735         System.out.println("--->" + resultMap.toString());
1736         assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
1737     }
1738
1739
1740     @Test
1741     public void Test7_onboardSearch() throws Exception {
1742         JsonOnboard jsonOnboard = new JsonOnboard();
1743         jsonOnboard.setAppname("TestApp2");
1744         jsonOnboard.setIsAAF("false");
1745         jsonOnboard.setAid(onboardUUID);
1746         Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
1747         resultMap.containsKey("success");
1748         assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
1749     }
1750
1751     // Missing appname
1752     @Test
1753     public void Test7_onboardSearch1() throws Exception {
1754         JsonOnboard jsonOnboard = new JsonOnboard();
1755         jsonOnboard.setIsAAF("false");
1756         jsonOnboard.setAid(onboardUUID);
1757         Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
1758         System.out.println("--->" + resultMap.toString());
1759         resultMap.containsKey("success");
1760         assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
1761     }
1762
1763     @Test
1764     public void Test7_onboardSearch_empty() throws Exception {
1765         JsonOnboard jsonOnboard = new JsonOnboard();
1766         Response response =  admin.getOnboardedInfoSearch(jsonOnboard);
1767         assertEquals(400, response.getStatus());
1768     }
1769
1770     @Test
1771     public void Test7_onboardSearch_invalidAid() throws Exception {
1772         JsonOnboard jsonOnboard = new JsonOnboard();
1773         jsonOnboard.setAppname("TestApp2");
1774         jsonOnboard.setIsAAF("false");
1775         jsonOnboard.setAid("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
1776         Response response = admin.getOnboardedInfoSearch(jsonOnboard);
1777         assertEquals(400, response.getStatus());
1778     }
1779
1780     @Test
1781     public void Test8_onboardUpdate() throws Exception {
1782         JsonOnboard jsonOnboard = new JsonOnboard();
1783         jsonOnboard.setIsAAF("false");
1784         jsonOnboard.setUserId("TestUser3");
1785         jsonOnboard.setPassword("TestPassword3");
1786         jsonOnboard.setAid(onboardUUID);
1787         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
1788         System.out.println("--->" + resultMap.toString());
1789         resultMap.containsKey("success");
1790         assertEquals("Your application has been updated successfully", resultMap.get("Success"));
1791     }
1792
1793     // Aid null
1794     @Test
1795     public void Test8_onboardUpdate1() throws Exception {
1796         JsonOnboard jsonOnboard = new JsonOnboard();
1797         jsonOnboard.setIsAAF("false");
1798         jsonOnboard.setUserId("TestUser3");
1799         jsonOnboard.setPassword("TestPassword3");
1800         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
1801         System.out.println("--->" + resultMap.toString());
1802         resultMap.containsKey("success");
1803         assertEquals("Please make sure Aid is present", resultMap.get("Exception"));
1804     }
1805
1806     // Appname not null
1807     @Test
1808     public void Test8_onboardUpdate2() throws Exception {
1809         JsonOnboard jsonOnboard = new JsonOnboard();
1810         jsonOnboard.setAppname("TestApp2");
1811         jsonOnboard.setIsAAF("false");
1812         jsonOnboard.setUserId("TestUser3");
1813         jsonOnboard.setPassword("TestPassword3");
1814         jsonOnboard.setAid(onboardUUID);
1815         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
1816         resultMap.containsKey("success");
1817         System.out.println("--->" + resultMap.toString());
1818         assertEquals("Application TestApp2 has already been onboarded. Please contact admin.", resultMap.get("Exception"));
1819     }
1820
1821     // All null
1822     @Test
1823     public void Test8_onboardUpdate3() throws Exception {
1824         JsonOnboard jsonOnboard = new JsonOnboard();
1825         jsonOnboard.setAid(onboardUUID);
1826         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
1827         assertTrue(resultMap.containsKey("Exception") );
1828     }
1829
1830     @Test
1831     public void Test9_onboardDelete() throws Exception {
1832         JsonOnboard jsonOnboard = new JsonOnboard();
1833         jsonOnboard.setAppname("TestApp2");
1834         jsonOnboard.setAid(onboardUUID);
1835         Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
1836         resultMap.containsKey("success");
1837         assertEquals("Your application has been deleted successfully", resultMap.get("Success"));
1838     }
1839
1840     @Test
1841     public void Test9_onboardDelete1() throws Exception {
1842         JsonOnboard jsonOnboard = new JsonOnboard();
1843         Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
1844         assertTrue(resultMap.containsKey("Exception"));
1845     }
1846
1847     @Test
1848     public void Test3_createLockReference() throws Exception {
1849         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1850         Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1",authorization, null, appName).getEntity();
1851         @SuppressWarnings("unchecked")
1852         Map<String, Object> resultMap1 = (Map<String, Object>) resultMap.get("lock");
1853         lockId = (String) resultMap1.get("lock");
1854         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1855     }
1856
1857     @Test
1858     public void Test4_accquireLock() throws Exception {
1859         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1860         Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLock(lockId,"1","1",authorization, null, appName).getEntity();
1861         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1862     }
1863
1864     @Test
1865     public void Test5_currentLockHolder() throws Exception {
1866         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1867         Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder(lockName,"1","1",authorization, null, appName).getEntity();
1868         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1869     }
1870
1871     @Test
1872     public void Test7_unLock() throws Exception {
1873         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1874         Map<String, Object> resultMap = (Map<String, Object>) lock.unLock(lockId,"1","1",authorization, null, appName).getEntity();
1875         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1876     }
1877
1878     @Test
1879     public void Test8_delete() throws Exception {
1880         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1881         Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null,authorization, appName).getEntity();
1882         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1883     }
1884
1885     // Version api
1886     @Test
1887     public void Test1_version( ) {
1888         RestMusicVersionAPI versionapi = new RestMusicVersionAPI();
1889         HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
1890         Map<String, Object> resultMap = versionapi.version(servletResponse);
1891         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1892     }
1893
1894     //Music Test Api
1895     @Test
1896     public void Test2_testAPI() {
1897         RestMusicTestAPI musicTest = new RestMusicTestAPI();
1898         HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
1899         Map<String, HashMap<String, String>> resultMap = musicTest.simpleTests(servletResponse);
1900         assertNotNull(resultMap);
1901     }
1902
1903     //Music Health Check
1904     @Test
1905     public void Test3_HealthCheck_cassandra() {
1906         String consistency = "ONE";
1907         RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
1908         HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
1909         Response response = healthCheck.cassandraStatus(servletResponse, consistency);
1910         assertEquals(200, response.getStatus());
1911     }
1912
1913     @Test
1914     public void Test3_HealthCheck_cassandra_cosistencyQuorum() {
1915         String consistency = "QUORUM";
1916         RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
1917         HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
1918         Response response = healthCheck.cassandraStatus(servletResponse, consistency);
1919         assertEquals(200, response.getStatus());
1920     }
1921
1922     @Test
1923     public void Test3_HealthCheck_zookeeper() {
1924         RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
1925         HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
1926         Response response = healthCheck.ZKStatus(servletResponse);
1927         assertEquals(200, response.getStatus());
1928     }
1929
1930     @Test
1931     public void Test4_pureZKcreate() throws Exception {
1932         RestMusicBmAPI bmApi = new RestMusicBmAPI();
1933         bmApi.pureZkCreate("sample");
1934     }
1935
1936     @Test
1937     public void Test4_pureZKUpdate() throws Exception {
1938         RestMusicBmAPI bmApi = new RestMusicBmAPI();
1939         bmApi.pureZkCreate("sample1");
1940         JsonInsert jsonInsert = new JsonInsert();
1941         Map<String, String> consistencyInfo = new HashMap<>();
1942         Map<String, Object> values = new HashMap<>();
1943         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1944         values.put("emp_name", "testName_create");
1945         values.put("emp_salary", 500);
1946         consistencyInfo.put("type", "eventual");
1947         jsonInsert.setConsistencyInfo(consistencyInfo);
1948         jsonInsert.setKeyspaceName(keyspaceName);
1949         jsonInsert.setTableName(tableName);
1950         jsonInsert.setValues(values);
1951         bmApi.pureZkUpdate(jsonInsert, "sampleNode1");
1952     }
1953
1954     @Test
1955     public void Test4_pureZKGet() throws Exception {
1956         RestMusicBmAPI bmApi = new RestMusicBmAPI();
1957         bmApi.pureZkGet("sample");
1958     }
1959
1960     @Test
1961     public void Test5_ZKAtomicPut_atomic() throws Exception {
1962         RestMusicBmAPI bmApi = new RestMusicBmAPI();
1963         JsonInsert jsonInsert = new JsonInsert();
1964         Map<String, String> consistencyInfo = new HashMap<>();
1965         Map<String, Object> values = new HashMap<>();
1966         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1967         values.put("emp_name", "testName_create");
1968         values.put("emp_salary", 1500);
1969         consistencyInfo.put("type", "atomic");
1970         jsonInsert.setConsistencyInfo(consistencyInfo);
1971         jsonInsert.setKeyspaceName(keyspaceName);
1972         jsonInsert.setTableName(tableName);
1973         jsonInsert.setValues(values);
1974         bmApi.pureZkAtomicPut(jsonInsert, "lockname", "sampleNode1");
1975     }
1976
1977     @Test
1978     public void Test5_ZKAtomicPut_atomic_with_delete() throws Exception {
1979         RestMusicBmAPI bmApi = new RestMusicBmAPI();
1980         JsonInsert jsonInsert = new JsonInsert();
1981         Map<String, String> consistencyInfo = new HashMap<>();
1982         Map<String, Object> values = new HashMap<>();
1983         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1984         values.put("emp_name", "testName_create");
1985         values.put("emp_salary", 1500);
1986         consistencyInfo.put("type", "atomic_delete_lock");
1987         jsonInsert.setConsistencyInfo(consistencyInfo);
1988         jsonInsert.setKeyspaceName(keyspaceName);
1989         jsonInsert.setTableName(tableName);
1990         jsonInsert.setValues(values);
1991         bmApi.pureZkAtomicPut(jsonInsert, "lockname", "sampleNode1");
1992     }
1993
1994     @Test
1995     public void Test5_ZKAtomicGet_atomic() throws Exception {
1996         RestMusicBmAPI bmApi = new RestMusicBmAPI();
1997         JsonInsert jsonInsert = new JsonInsert();
1998         Map<String, String> consistencyInfo = new HashMap<>();
1999         Map<String, Object> values = new HashMap<>();
2000         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
2001         values.put("emp_name", "testName_create");
2002         values.put("emp_salary", 1500);
2003         consistencyInfo.put("type", "atomic_delete_lock");
2004         jsonInsert.setConsistencyInfo(consistencyInfo);
2005         jsonInsert.setKeyspaceName(keyspaceName);
2006         jsonInsert.setTableName(tableName);
2007         jsonInsert.setValues(values);
2008         bmApi.pureZkAtomicGet(jsonInsert, "lockname", "sampleNode1");
2009     }
2010
2011     @Test
2012     public void Test5_ZKAtomicGet_atomic_with_delete() throws Exception {
2013         RestMusicBmAPI bmApi = new RestMusicBmAPI();
2014         JsonInsert jsonInsert = new JsonInsert();
2015         Map<String, String> consistencyInfo = new HashMap<>();
2016         Map<String, Object> values = new HashMap<>();
2017         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
2018         values.put("emp_name", "testName_create");
2019         values.put("emp_salary", 1500);
2020         consistencyInfo.put("type", "atomic_delete_lock");
2021         jsonInsert.setConsistencyInfo(consistencyInfo);
2022         jsonInsert.setKeyspaceName(keyspaceName);
2023         jsonInsert.setTableName(tableName);
2024         jsonInsert.setValues(values);
2025         bmApi.pureZkAtomicGet(jsonInsert, "lockname", "sampleNode1");
2026     }
2027
2028     @Test
2029     public void Test5_updateCassa() throws Exception {
2030         RestMusicBmAPI bmApi = new RestMusicBmAPI();
2031         JsonInsert jsonInsert = new JsonInsert();
2032         Map<String, String> consistencyInfo = new HashMap<>();
2033         Map<String, Object> values = new HashMap<>();
2034         values.put("emp_salary", 1500);
2035         consistencyInfo.put("type", "eventual");
2036         jsonInsert.setConsistencyInfo(consistencyInfo);
2037         jsonInsert.setKeyspaceName(keyspaceName);
2038         jsonInsert.setTableName(tableName);
2039         jsonInsert.setValues(values);
2040         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
2041         row.add("emp_name", "testName_create");
2042         Mockito.when(info.getQueryParameters()).thenReturn(row);
2043         bmApi.updateTableCassa(jsonInsert, keyspaceName, tableName, info);
2044     }
2045
2046     // RestMusicConditional
2047     @Test
2048     public void Test5_createTable_conditional() throws Exception {
2049         JsonTable jsonTable = new JsonTable();
2050         Map<String, String> consistencyInfo = new HashMap<>();
2051         Map<String, String> fields = new HashMap<>();
2052         fields.put("id", "text");
2053         fields.put("plans", "Map<text,text>");
2054         fields.put("PRIMARY KEY", "(id)");
2055         consistencyInfo.put("type", "eventual");
2056         jsonTable.setConsistencyInfo(consistencyInfo);
2057         jsonTable.setKeyspaceName(keyspaceName);
2058         jsonTable.setPrimaryKey("id");
2059         jsonTable.setTableName(tableNameConditional);
2060         jsonTable.setFields(fields);
2061         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2062         Response response = data.createTable("1", "1", "1",
2063                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
2064                         jsonTable, keyspaceName, tableNameConditional);
2065         System.out.println("#######status is " + response.getStatus());
2066         System.out.println("Entity" + response.getEntity());
2067         assertEquals(200, response.getStatus());
2068     }
2069
2070     @Test
2071     public void Test6_insertConditional() throws Exception {
2072         RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2073         JsonConditional json = new JsonConditional();
2074         json.setPrimaryKey("id");
2075         json.setPrimaryKeyValue("123|abc|port");
2076         json.setCasscadeColumnName("plans");
2077         Map<String, Object> tableValues =  new HashMap<>();
2078         tableValues.put("id", "123|abc|port");
2079         json.setTableValues(tableValues);
2080         Map<String, Object> columnData =  new HashMap<>();
2081         Map<String, String> column =  new HashMap<>();
2082         column.put("created", "time");
2083         columnData.put("key", "P2");
2084         columnData.put("value", column);
2085         json.setCasscadeColumnData(columnData);
2086         Map<String, String> cond = new HashMap<>();
2087         Map<String, String> cond1 = new HashMap<>();
2088         Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2089         cond.put("status", "under-spin-up");
2090         cond1.put("status", "parked");
2091         conditions.put("exists", cond);
2092         conditions.put("nonexists", cond1);
2093         json.setConditions(conditions);
2094         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2095         Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2096                 appName, authorization, keyspaceName, tableNameConditional, json);
2097         assertEquals(200, response.getStatus());
2098     }
2099
2100     @Test
2101     public void Test6_insertConditional_primaryKey_null() throws Exception {
2102         RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2103         JsonConditional json = new JsonConditional();
2104         json.setPrimaryKeyValue("123|abc|port");
2105         json.setCasscadeColumnName("plans");
2106         Map<String, Object> tableValues =  new HashMap<>();
2107         tableValues.put("id", "123|abc|port");
2108         json.setTableValues(tableValues);
2109         Map<String, Object> columnData =  new HashMap<>();
2110         Map<String, String> column =  new HashMap<>();
2111         column.put("created", "time");
2112         columnData.put("key", "P2");
2113         columnData.put("value", column);
2114         json.setCasscadeColumnData(columnData);
2115         Map<String, String> cond = new HashMap<>();
2116         Map<String, String> cond1 = new HashMap<>();
2117         Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2118         cond.put("status", "under-spin-up");
2119         cond1.put("status", "parked");
2120         conditions.put("exists", cond);
2121         conditions.put("nonexists", cond1);
2122         json.setConditions(conditions);
2123         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2124         Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2125                 appName, authorization, keyspaceName, tableNameConditional, json);
2126         assertEquals(401, response.getStatus());
2127     }
2128
2129     @Test
2130     public void Test6_insertConditional_wrongAuth() throws Exception {
2131         RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2132         JsonConditional json = new JsonConditional();
2133         json.setPrimaryKey("id");
2134         json.setPrimaryKeyValue("123|abc|port");
2135         json.setCasscadeColumnName("plans");
2136         Map<String, Object> tableValues =  new HashMap<>();
2137         tableValues.put("id", "123|abc|port");
2138         json.setTableValues(tableValues);
2139         Map<String, Object> columnData =  new HashMap<>();
2140         Map<String, String> column =  new HashMap<>();
2141         column.put("created", "time");
2142         columnData.put("key", "P2");
2143         columnData.put("value", column);
2144         json.setCasscadeColumnData(columnData);
2145         Map<String, String> cond = new HashMap<>();
2146         Map<String, String> cond1 = new HashMap<>();
2147         Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2148         cond.put("status", "under-spin-up");
2149         cond1.put("status", "parked");
2150         conditions.put("exists", cond);
2151         conditions.put("nonexists", cond1);
2152         json.setConditions(conditions);
2153         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2154         Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2155                 appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
2156         assertEquals(401, response.getStatus());
2157     }
2158
2159     @Test
2160     public void Test7_updateConditional() throws Exception {
2161         RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2162         JsonConditional json = new JsonConditional();
2163         json.setPrimaryKey("id");
2164         json.setPrimaryKeyValue("123|abc|port");
2165         json.setCasscadeColumnName("plans");
2166         Map<String, Object> tableValues =  new HashMap<>();
2167         tableValues.put("id", "123|abc|port");
2168         json.setTableValues(tableValues);
2169         Map<String, Object> columnData =  new HashMap<>();
2170         Map<String, String> column =  new HashMap<>();
2171         column.put("created", "time");
2172         columnData.put("key", "P2");
2173         columnData.put("value", column);
2174         json.setCasscadeColumnData(columnData);
2175         Map<String, String> cond = new HashMap<>();
2176         Map<String, String> cond1 = new HashMap<>();
2177         Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2178         cond.put("updated", "new time");
2179         conditions.put("exists", cond);
2180         conditions.put("nonexists", cond1);
2181         json.setConditions(conditions);
2182         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2183         Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2184                 appName, authorization, keyspaceName, tableNameConditional, json);
2185         assertEquals(200, response.getStatus());
2186     }
2187
2188     @Test
2189     public void Test7_updateConditional_wrongAuth() throws Exception {
2190         RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2191         JsonConditional json = new JsonConditional();
2192         json.setPrimaryKey("id");
2193         json.setPrimaryKeyValue("123|abc|port");
2194         json.setCasscadeColumnName("plans");
2195         Map<String, Object> tableValues =  new HashMap<>();
2196         tableValues.put("id", "123|abc|port");
2197         json.setTableValues(tableValues);
2198         Map<String, Object> columnData =  new HashMap<>();
2199         Map<String, String> column =  new HashMap<>();
2200         column.put("created", "time");
2201         columnData.put("key", "P2");
2202         columnData.put("value", column);
2203         json.setCasscadeColumnData(columnData);
2204         Map<String, String> cond = new HashMap<>();
2205         Map<String, String> cond1 = new HashMap<>();
2206         Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2207         cond.put("updated", "new time");
2208         conditions.put("exists", cond);
2209         conditions.put("nonexists", cond1);
2210         json.setConditions(conditions);
2211         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2212         Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2213                 appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
2214         assertEquals(401, response.getStatus());
2215     }
2216
2217     @Test
2218     public void Test7_updateConditional_primarykey_null() throws Exception {
2219         RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2220         JsonConditional json = new JsonConditional();
2221         json.setPrimaryKeyValue("123|abc|port");
2222         json.setCasscadeColumnName("plans");
2223         Map<String, Object> tableValues =  new HashMap<>();
2224         tableValues.put("id", "123|abc|port");
2225         json.setTableValues(tableValues);
2226         Map<String, Object> columnData =  new HashMap<>();
2227         Map<String, String> column =  new HashMap<>();
2228         column.put("created", "time");
2229         columnData.put("key", "P2");
2230         columnData.put("value", column);
2231         json.setCasscadeColumnData(columnData);
2232         Map<String, String> cond = new HashMap<>();
2233         Map<String, String> cond1 = new HashMap<>();
2234         Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2235         cond.put("updated", "new time");
2236         conditions.put("exists", cond);
2237         conditions.put("nonexists", cond1);
2238         json.setConditions(conditions);
2239         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2240         Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2241                 appName, authorization, keyspaceName, tableNameConditional, json);
2242         assertEquals(401, response.getStatus());
2243     }
2244 }