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