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

   1 /*
   2  * ============LICENSE_START==========================================
   3  * org.onap.music
   4  * ===================================================================
   5  *  Copyright (c) 2019 AT&T Intellectual Property
   6  * ===================================================================
   7  *  Licensed under the Apache License, Version 2.0 (the "License");
   8  *  you may not use this file except in compliance with the License.
   9  *  You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  *  Unless required by applicable law or agreed to in writing, software
  14  *  distributed under the License is distributed on an "AS IS" BASIS,
  15  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  *  See the License for the specific language governing permissions and
  17  *  limitations under the License.
  18  *
  19  * ============LICENSE_END=============================================
  20  * ====================================================================
  21  */
  22
  23 package org.onap.music.unittests;
  24
  25 import static org.junit.Assert.assertEquals;
  26 import java.math.BigInteger;
  27 import java.util.ArrayList;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.UUID;
  32 import javax.servlet.http.HttpServletResponse;
  33 import javax.ws.rs.core.MultivaluedHashMap;
  34 import javax.ws.rs.core.MultivaluedMap;
  35 import javax.ws.rs.core.Response;
  36 import javax.ws.rs.core.UriInfo;
  37 import org.junit.After;
  38 import org.junit.AfterClass;
  39 import org.junit.BeforeClass;
  40 import org.junit.Ignore;
  41 import org.junit.Test;
  42 import org.junit.runner.RunWith;
  43 import org.mindrot.jbcrypt.BCrypt;
  44 import org.mockito.Mock;
  45 import org.mockito.Mockito;
  46 import org.mockito.junit.MockitoJUnitRunner;
  47 import org.onap.music.datastore.MusicDataStoreHandle;
  48 import org.onap.music.datastore.PreparedQueryObject;
  49 import org.onap.music.datastore.jsonobjects.JsonDelete;
  50 import org.onap.music.datastore.jsonobjects.JsonInsert;
  51 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
  52 import org.onap.music.datastore.jsonobjects.JsonSelect;
  53 import org.onap.music.datastore.jsonobjects.JsonTable;
  54 import org.onap.music.datastore.jsonobjects.JsonUpdate;
  55 import org.onap.music.exceptions.MusicServiceException;
  56 import org.onap.music.main.MusicCore;
  57 import org.onap.music.main.MusicUtil;
  58 import org.onap.music.main.ResultType;
  59 import org.onap.music.rest.RestMusicDataAPI;
  60 import org.onap.music.rest.RestMusicLocksAPI;
  61 import com.datastax.driver.core.DataType;
  62 import com.datastax.driver.core.ResultSet;
  63 import com.datastax.driver.core.Row;
  64 import com.sun.jersey.core.util.Base64;
  65 import com.sun.jersey.core.util.MultivaluedMapImpl;
  66
  67 @RunWith(MockitoJUnitRunner.class)
  68 public class TstRestMusicDataAPI {
  69
  70         RestMusicDataAPI data = new RestMusicDataAPI();
  71         RestMusicLocksAPI lock = new RestMusicLocksAPI();
  72         static PreparedQueryObject testObject;
  73
  74         @Mock
  75         HttpServletResponse http;
  76
  77         @Mock
  78         UriInfo info;
  79
  80     static String appName = "TestApp";
  81     static String userId = "TestUser";
  82     static String password = "TestPassword";
  83     static String authData = userId + ":" + password;
  84     static String wrongAuthData = userId + ":" + "pass";
  85     static String authorization = new String(Base64.encode(authData.getBytes()));
  86     static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
  87     static boolean isAAF = false;
  88     static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
  89     static String keyspaceName = "testcassa";
  90     static String tableName = "employees";
  91     static String xLatestVersion = "X-latestVersion";
  92     static String onboardUUID = null;
  93     static String aid = TestsUsingCassandra.aid;
  94
  95     @BeforeClass
  96     public static void init() throws Exception {
  97         System.out.println("Testing RestMusicData class");
  98         try {
  99             createKeyspace();
 100         } catch (Exception e) {
 101             e.printStackTrace();
 102             throw new Exception("Unable to initialize before TestRestMusicData test class. " + e.getMessage());
 103         }
 104     }
 105
 106     @After
 107     public void afterEachTest() throws MusicServiceException {
 108         clearAllTablesFromKeyspace();
 109     }
 110
 111     @AfterClass
 112     public static void tearDownAfterClass() throws Exception {
 113         testObject = new PreparedQueryObject();
 114         testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
 115         MusicCore.eventualPut(testObject);
 116     }
 117
 118     @Test
 119     public void test1_createKeyspace() throws Exception {
 120         System.out.println("Testing create keyspace");
 121         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 122         Map<String, String> consistencyInfo = new HashMap<>();
 123         Map<String, Object> replicationInfo = new HashMap<>();
 124         consistencyInfo.put("type", "eventual");
 125         replicationInfo.put("class", "SimpleStrategy");
 126         replicationInfo.put("replication_factor", 1);
 127         jsonKeyspace.setConsistencyInfo(consistencyInfo);
 128         jsonKeyspace.setDurabilityOfWrites("true");
 129         jsonKeyspace.setKeyspaceName(keyspaceName);
 130         jsonKeyspace.setReplicationInfo(replicationInfo);
 131         // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 132         Response response =
 133                 data.createKeySpace("1", "1", "1", null, authorization, appName, jsonKeyspace, keyspaceName);
 134         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 135         assertEquals(400, response.getStatus());
 136         Map<String, String> respMap = (Map<String, String>) response.getEntity();
 137         assertEquals(ResultType.FAILURE, respMap.get("status"));
 138     }
 139
 140     @Test
 141     public void test1_createKeyspaceSuccess() throws Exception {
 142         System.out.println("Testing successful creation and deletion of keyspace");
 143         MusicUtil.setKeyspaceActive(true);
 144
 145         String keyspaceToCreate = "temp"+keyspaceName;
 146
 147
 148         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 149         Map<String, String> consistencyInfo = new HashMap<>();
 150         Map<String, Object> replicationInfo = new HashMap<>();
 151         consistencyInfo.put("type", "eventual");
 152         replicationInfo.put("class", "SimpleStrategy");
 153         replicationInfo.put("replication_factor", 1);
 154         jsonKeyspace.setConsistencyInfo(consistencyInfo);
 155         jsonKeyspace.setDurabilityOfWrites("true");
 156         //don't overwrite a keyspace we already have
 157         jsonKeyspace.setKeyspaceName(keyspaceToCreate);
 158         jsonKeyspace.setReplicationInfo(replicationInfo);
 159         // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 160         Response response =
 161                 data.createKeySpace("1", "1", "1", null, authorization, appName, jsonKeyspace, keyspaceToCreate);
 162         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 163         assertEquals(200, response.getStatus());
 164         Map<String, String> respMap = (Map<String, String>) response.getEntity();
 165         assertEquals(ResultType.SUCCESS, respMap.get("status"));
 166
 167         response = data.dropKeySpace("1", "1", "1", null, authorization, appName, keyspaceToCreate);
 168         assertEquals(200, response.getStatus());
 169         respMap = (Map<String, String>) response.getEntity();
 170         assertEquals(ResultType.SUCCESS, respMap.get("status"));
 171
 172         //unset to not mess up any further tests
 173         MusicUtil.setKeyspaceActive(false);
 174     }
 175
 176     @Test
 177     public void test3_createTable() throws Exception {
 178         System.out.println("Testing create table");
 179         JsonTable jsonTable = new JsonTable();
 180         Map<String, String> consistencyInfo = new HashMap<>();
 181         Map<String, String> fields = new HashMap<>();
 182         fields.put("uuid", "text");
 183         fields.put("emp_name", "text");
 184         fields.put("emp_salary", "varint");
 185         fields.put("PRIMARY KEY", "(emp_name)");
 186         consistencyInfo.put("type", "eventual");
 187         jsonTable.setConsistencyInfo(consistencyInfo);
 188         jsonTable.setKeyspaceName(keyspaceName);
 189         jsonTable.setPrimaryKey("emp_name");
 190         jsonTable.setTableName(tableName);
 191         jsonTable.setFields(fields);
 192         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 193                 authorization, jsonTable, keyspaceName, tableName);
 194         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 195         assertEquals(200, response.getStatus());
 196     }
 197
 198     @Test
 199     public void test3_createTableNoBody() throws Exception {
 200         System.out.println("Testing create table w/o body");
 201
 202         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 203                 authorization, null, keyspaceName, tableName);
 204         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 205         assertEquals(400, response.getStatus());
 206     }
 207
 208     @Test
 209     public void test3_createTableNoName() throws Exception {
 210         System.out.println("Testing create table without name");
 211         JsonTable jsonTable = new JsonTable();
 212         Map<String, String> consistencyInfo = new HashMap<>();
 213         Map<String, String> fields = new HashMap<>();
 214         fields.put("uuid", "text");
 215         fields.put("emp_name", "text");
 216         fields.put("emp_salary", "varint");
 217         fields.put("PRIMARY KEY", "(emp_name)");
 218         consistencyInfo.put("type", "eventual");
 219         jsonTable.setConsistencyInfo(consistencyInfo);
 220         jsonTable.setKeyspaceName(keyspaceName);
 221         jsonTable.setPrimaryKey("emp_name");
 222         jsonTable.setTableName("");
 223         jsonTable.setFields(fields);
 224         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 225                 authorization, jsonTable, keyspaceName, "");
 226         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 227         assertEquals(400, response.getStatus());
 228     }
 229
 230     @Test
 231     public void test3_createTableNoFields() throws Exception {
 232         System.out.println("Testing create table without fields");
 233         JsonTable jsonTable = new JsonTable();
 234         Map<String, String> consistencyInfo = new HashMap<>();
 235         consistencyInfo.put("type", "eventual");
 236         jsonTable.setConsistencyInfo(consistencyInfo);
 237         jsonTable.setKeyspaceName(keyspaceName);
 238         jsonTable.setPrimaryKey("emp_name");
 239         jsonTable.setTableName("");
 240         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 241                 authorization, jsonTable, keyspaceName, "");
 242         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 243         assertEquals(400, response.getStatus());
 244     }
 245
 246
 247     @Test
 248     public void test3_createTableClusterOrderBad() throws Exception {
 249         System.out.println("Testing create table bad clustering");
 250         JsonTable jsonTable = new JsonTable();
 251         Map<String, String> consistencyInfo = new HashMap<>();
 252         Map<String, String> fields = new HashMap<>();
 253         fields.put("uuid", "text");
 254         fields.put("emp_name", "text");
 255         fields.put("emp_salary", "varint");
 256         fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
 257         consistencyInfo.put("type", "eventual");
 258         jsonTable.setConsistencyInfo(consistencyInfo);
 259         jsonTable.setKeyspaceName(keyspaceName);
 260         jsonTable.setPrimaryKey("emp_name,emp_salary");
 261         jsonTable.setClusteringOrder("ASC");
 262         jsonTable.setTableName(tableName);
 263         jsonTable.setFields(fields);
 264         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 265                 authorization, jsonTable, keyspaceName, tableName);
 266         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 267         assertEquals(400, response.getStatus());
 268     }
 269
 270     @Test
 271     public void test3_createTable_withPropertiesNotNull() throws Exception {
 272         System.out.println("Testing create table with properties");
 273         JsonTable jsonTable = new JsonTable();
 274         Map<String, String> consistencyInfo = new HashMap<>();
 275         Map<String, String> fields = new HashMap<>();
 276         fields.put("uuid", "text");
 277         fields.put("emp_name", "text");
 278         fields.put("emp_salary", "varint");
 279         fields.put("PRIMARY KEY", "(emp_name)");
 280         consistencyInfo.put("type", "eventual");
 281         Map<String, Object> properties = new HashMap<>();
 282         properties.put("comment", "Testing prperties not null");
 283         jsonTable.setConsistencyInfo(consistencyInfo);
 284         jsonTable.setKeyspaceName(keyspaceName);
 285         jsonTable.setPrimaryKey("emp_name");
 286         String tableName_prop = tableName + "_Prop";
 287         jsonTable.setTableName(tableName_prop);
 288         jsonTable.setFields(fields);
 289         jsonTable.setProperties(properties);
 290
 291         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 292                 authorization, jsonTable, keyspaceName, tableName_prop);
 293         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 294         assertEquals(200, response.getStatus());
 295     }
 296
 297     @Test
 298     public void test3_createTable_duplicateTable() throws Exception {
 299         System.out.println("Testing creating duplicate tables");
 300         JsonTable jsonTable = new JsonTable();
 301         Map<String, String> consistencyInfo = new HashMap<>();
 302         Map<String, String> fields = new HashMap<>();
 303         fields.put("uuid", "text");
 304         fields.put("emp_name", "text");
 305         fields.put("emp_salary", "varint");
 306         fields.put("PRIMARY KEY", "(emp_name)");
 307         consistencyInfo.put("type", "eventual");
 308         jsonTable.setConsistencyInfo(consistencyInfo);
 309         jsonTable.setKeyspaceName(keyspaceName);
 310         jsonTable.setPrimaryKey("emp_name");
 311         String tableNameDup = tableName + "x";
 312         jsonTable.setTableName(tableNameDup);
 313         jsonTable.setFields(fields);
 314         // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 315         Response response1 = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 316                 authorization, jsonTable, keyspaceName, tableNameDup);
 317
 318         Response response2 = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 319                 authorization, jsonTable, keyspaceName, tableNameDup);
 320         System.out.println("Status: " + response2.getStatus() + ". Entity " + response2.getEntity());
 321
 322         assertEquals(400, response2.getStatus());
 323         Map<String, String> respMap = (Map<String, String>) response2.getEntity();
 324         assertEquals(ResultType.FAILURE, respMap.get("status"));
 325         assertEquals("AlreadyExistsException: Table " + keyspaceName + "." + tableNameDup + " already exists", respMap.get("error"));
 326     }
 327
 328
 329     // Improper parenthesis in key field
 330     @Test
 331     public void test3_createTable_badParanthesis() throws Exception {
 332         System.out.println("Testing malformed create table request");
 333         String tableNameC = "testTable0";
 334         JsonTable jsonTable = new JsonTable();
 335         Map<String, String> consistencyInfo = new HashMap<>();
 336         Map<String, String> fields = new HashMap<>();
 337         fields.put("uuid", "text");
 338         fields.put("emp_name", "text");
 339         fields.put("emp_salary", "varint");
 340         fields.put("PRIMARY KEY", "(emp_name),emp_id)");
 341         fields.put("emp_id", "varint");
 342         consistencyInfo.put("type", "eventual");
 343         jsonTable.setConsistencyInfo(consistencyInfo);
 344         jsonTable.setKeyspaceName(keyspaceName);
 345         jsonTable.setPrimaryKey("emp_name");
 346         jsonTable.setTableName(tableNameC);
 347         jsonTable.setClusteringOrder("emp_id Desc");
 348         jsonTable.setFields(fields);
 349         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 350                 authorization, jsonTable, keyspaceName, tableNameC);
 351         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 352
 353         assertEquals(400, response.getStatus());
 354     }
 355
 356
 357     // good clustering key
 358     @Test
 359     public void test3_createTable_1_clusterKey_good() throws Exception {
 360         System.out.println("Testing create w/ clusterKey");
 361
 362         String tableNameC = "testTableC1";
 363         JsonTable jsonTable = new JsonTable();
 364         Map<String, String> consistencyInfo = new HashMap<>();
 365         Map<String, String> fields = new HashMap<>();
 366         fields.put("uuid", "text");
 367         fields.put("emp_name", "text");
 368         fields.put("emp_salary", "varint");
 369         fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 370         consistencyInfo.put("type", "eventual");
 371         jsonTable.setConsistencyInfo(consistencyInfo);
 372         jsonTable.setKeyspaceName(keyspaceName);
 373         // jsonTable.setPrimaryKey("emp_name");
 374         jsonTable.setTableName(tableNameC);
 375         jsonTable.setClusteringOrder("emp_salary ASC");
 376         jsonTable.setFields(fields);
 377         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 378                 authorization, jsonTable, keyspaceName, tableNameC);
 379         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 380
 381         assertEquals(200, response.getStatus());
 382     }
 383
 384     // bad partition key=clustering key
 385     @Test
 386     public void test3_createTable_2_clusterKey_bad() throws Exception {
 387         System.out.println("Testing create w/ bad clusterKey");
 388         String tableNameC = "testTableC2";
 389         JsonTable jsonTable = new JsonTable();
 390         Map<String, String> consistencyInfo = new HashMap<>();
 391         Map<String, String> fields = new HashMap<>();
 392         fields.put("uuid", "text");
 393         fields.put("emp_name", "text");
 394         fields.put("emp_salary", "varint");
 395         fields.put("PRIMARY KEY", "((emp_name),emp_name)");
 396         consistencyInfo.put("type", "eventual");
 397         jsonTable.setConsistencyInfo(consistencyInfo);
 398         jsonTable.setKeyspaceName(keyspaceName);
 399         jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
 400         jsonTable.setTableName(tableNameC);
 401         jsonTable.setClusteringOrder("emp_salary ASC");
 402         jsonTable.setFields(fields);
 403         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 404                 authorization, jsonTable, keyspaceName, tableNameC);
 405         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 406
 407         assertEquals(400, response.getStatus());
 408     }
 409
 410     // good composite partition key,clustering key
 411     @Test
 412     public void test3_createTable_3_pfartition_clusterKey_good() throws Exception {
 413         System.out.println("Testing create w/ composite partition key, clusterKey");
 414
 415         String tableNameC = "testTableC3";
 416         JsonTable jsonTable = new JsonTable();
 417         Map<String, String> consistencyInfo = new HashMap<>();
 418         Map<String, String> fields = new HashMap<>();
 419         fields.put("uuid", "text");
 420         fields.put("emp_name", "text");
 421         fields.put("emp_id", "varint");
 422         fields.put("emp_salary", "varint");
 423         fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
 424         consistencyInfo.put("type", "eventual");
 425         jsonTable.setConsistencyInfo(consistencyInfo);
 426         jsonTable.setKeyspaceName(keyspaceName);
 427         jsonTable.setPrimaryKey("emp_name");
 428         jsonTable.setTableName(tableNameC);
 429         jsonTable.setClusteringOrder("emp_salary ASC");
 430         jsonTable.setFields(fields);
 431         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 432                 authorization, jsonTable, keyspaceName, tableNameC);
 433         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 434
 435         assertEquals(200, response.getStatus());
 436     }
 437
 438     // bad - wrong cols in order by of composite partition key,clustering key
 439     @Test
 440     public void test3_createTable_5_clusteringOrder_bad() throws Exception {
 441         System.out.println("Testing create table bad request with clustering & composite keys");
 442         String tableNameC = "testTableC5";
 443         JsonTable jsonTable = new JsonTable();
 444         Map<String, String> consistencyInfo = new HashMap<>();
 445         Map<String, String> fields = new HashMap<>();
 446         fields.put("uuid", "text");
 447         fields.put("emp_name", "text");
 448         fields.put("emp_id", "varint");
 449         fields.put("emp_salary", "varint");
 450         fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
 451         consistencyInfo.put("type", "eventual");
 452         jsonTable.setConsistencyInfo(consistencyInfo);
 453         jsonTable.setKeyspaceName(keyspaceName);
 454         jsonTable.setPrimaryKey("emp_name");
 455         jsonTable.setTableName(tableNameC);
 456         jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
 457         jsonTable.setFields(fields);
 458         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 459                 authorization, jsonTable, keyspaceName, tableNameC);
 460         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 461
 462         assertEquals(400, response.getStatus());
 463     }
 464
 465
 466     // good clustering key, need to pass queryparameter
 467     @Test
 468     public void test3_createTableIndex_1() throws Exception {
 469         System.out.println("Testing index in create table");
 470         String tableNameC = "testTableCinx";
 471         JsonTable jsonTable = new JsonTable();
 472         Map<String, String> consistencyInfo = new HashMap<>();
 473         Map<String, String> fields = new HashMap<>();
 474         fields.put("uuid", "text");
 475         fields.put("emp_name", "text");
 476         fields.put("emp_salary", "varint");
 477         fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 478         consistencyInfo.put("type", "eventual");
 479         jsonTable.setConsistencyInfo(consistencyInfo);
 480         jsonTable.setKeyspaceName(keyspaceName);
 481         jsonTable.setTableName(tableNameC);
 482         jsonTable.setClusteringOrder("emp_salary ASC");
 483         jsonTable.setFields(fields);
 484         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 485                 authorization, jsonTable, keyspaceName, tableNameC);
 486         // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
 487         // info.setQueryParameters("index_name=inx_uuid");
 488         Map<String, String> queryParametersMap = new HashMap<String, String>();
 489
 490         queryParametersMap.put("index_name", "inxuuid");
 491         Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedHashMap<String, String>(queryParametersMap));
 492         response = data.createIndex("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 493                 keyspaceName, tableNameC, "uuid", info);
 494         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 495
 496         assertEquals(200, response.getStatus());
 497     }
 498
 499     // create index without table name
 500     @Test
 501     public void test3_createTableIndexNoName() throws Exception {
 502         System.out.println("Testing index in create table w/o tablename");
 503         String tableNameC = "testTableCinx";
 504         JsonTable jsonTable = new JsonTable();
 505         Map<String, String> consistencyInfo = new HashMap<>();
 506         Map<String, String> fields = new HashMap<>();
 507         fields.put("uuid", "text");
 508         fields.put("emp_name", "text");
 509         fields.put("emp_salary", "varint");
 510         fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 511         consistencyInfo.put("type", "eventual");
 512         jsonTable.setConsistencyInfo(consistencyInfo);
 513         jsonTable.setKeyspaceName(keyspaceName);
 514         jsonTable.setTableName(tableNameC);
 515         jsonTable.setClusteringOrder("emp_salary ASC");
 516         jsonTable.setFields(fields);
 517         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 518                 authorization, jsonTable, keyspaceName, tableNameC);
 519         // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
 520         // info.setQueryParameters("index_name=inx_uuid");
 521         Map<String, String> queryParametersMap = new HashMap<String, String>();
 522
 523         queryParametersMap.put("index_name", "inxuuid");
 524         response = data.createIndex("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization, "",
 525                 "", "uuid", info);
 526         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 527
 528         assertEquals(400, response.getStatus());
 529     }
 530
 531     @Test
 532     public void test4_insertIntoTable() throws Exception {
 533         System.out.println("Testing insert into table");
 534         createTable();
 535         JsonInsert jsonInsert = new JsonInsert();
 536         Map<String, String> consistencyInfo = new HashMap<>();
 537         Map<String, Object> values = new HashMap<>();
 538         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 539         values.put("emp_name", "testname");
 540         values.put("emp_salary", 500);
 541         consistencyInfo.put("type", "eventual");
 542         jsonInsert.setConsistencyInfo(consistencyInfo);
 543         jsonInsert.setKeyspaceName(keyspaceName);
 544         jsonInsert.setTableName(tableName);
 545         jsonInsert.setValues(values);
 546         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 547                 authorization, jsonInsert, keyspaceName, tableName);
 548         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 549
 550         assertEquals(200, response.getStatus());
 551     }
 552
 553     @Test
 554     public void test4_insertIntoTableNoBody() throws Exception {
 555         System.out.println("Testing insert into table w/o body");
 556         createTable();
 557         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 558                 authorization, null, keyspaceName, tableName);
 559         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 560
 561         assertEquals(400, response.getStatus());
 562     }
 563
 564     @Test
 565     public void test4_insertIntoTableNoaValues() throws Exception {
 566         System.out.println("Testing insert into table");
 567         createTable();
 568         JsonInsert jsonInsert = new JsonInsert();
 569         Map<String, String> consistencyInfo = new HashMap<>();
 570         consistencyInfo.put("type", "eventual");
 571         jsonInsert.setConsistencyInfo(consistencyInfo);
 572         jsonInsert.setKeyspaceName(keyspaceName);
 573         jsonInsert.setTableName(tableName);
 574
 575         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 576                 authorization, jsonInsert, keyspaceName, tableName);
 577         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 578
 579         assertEquals(400, response.getStatus());
 580     }
 581
 582     @Test
 583     public void test4_insertIntoTableNoValues() throws Exception {
 584         System.out.println("Testing insert into table");
 585         createTable();
 586         JsonInsert jsonInsert = new JsonInsert();
 587         Map<String, String> consistencyInfo = new HashMap<>();
 588         consistencyInfo.put("type", "eventual");
 589         jsonInsert.setConsistencyInfo(consistencyInfo);
 590         jsonInsert.setKeyspaceName(keyspaceName);
 591         jsonInsert.setTableName(tableName);
 592
 593         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 594                 authorization, jsonInsert, keyspaceName, tableName);
 595         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 596
 597         assertEquals(400, response.getStatus());
 598     }
 599
 600     @Test
 601     public void test4_insertIntoTableCriticalNoLockID() throws Exception {
 602         System.out.println("Testing critical insert into table without lockid");
 603         createTable();
 604         JsonInsert jsonInsert = new JsonInsert();
 605         Map<String, String> consistencyInfo = new HashMap<>();
 606         Map<String, Object> values = new HashMap<>();
 607         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 608         values.put("emp_name", "testname");
 609         values.put("emp_salary", 500);
 610         consistencyInfo.put("type", "critical");
 611         jsonInsert.setConsistencyInfo(consistencyInfo);
 612         jsonInsert.setKeyspaceName(keyspaceName);
 613         jsonInsert.setTableName(tableName);
 614         jsonInsert.setValues(values);
 615         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 616                 appName, authorization, jsonInsert, keyspaceName, tableName);
 617         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 618
 619         assertEquals(400, response.getStatus());
 620     }
 621
 622     @Test
 623     public void test4_insertIntoTableAtomic() throws Exception {
 624         System.out.println("Testing atomic insert into table without lockid");
 625         createTable();
 626         JsonInsert jsonInsert = new JsonInsert();
 627         Map<String, String> consistencyInfo = new HashMap<>();
 628         Map<String, Object> values = new HashMap<>();
 629         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 630         values.put("emp_name", "testname");
 631         values.put("emp_salary", 500);
 632         consistencyInfo.put("type", "atomic");
 633         jsonInsert.setConsistencyInfo(consistencyInfo);
 634         jsonInsert.setKeyspaceName(keyspaceName);
 635         jsonInsert.setTableName(tableName);
 636         jsonInsert.setValues(values);
 637         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 638                 appName, authorization, jsonInsert, keyspaceName, tableName);
 639         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 640
 641         assertEquals(200, response.getStatus());
 642     }
 643
 644     @Test
 645     public void test4_insertIntoTableNoName() throws Exception {
 646         System.out.println("Testing insert into table w/o table name");
 647         createTable();
 648         JsonInsert jsonInsert = new JsonInsert();
 649         Map<String, String> consistencyInfo = new HashMap<>();
 650         Map<String, Object> values = new HashMap<>();
 651         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 652         values.put("emp_name", "testname");
 653         values.put("emp_salary", 500);
 654         consistencyInfo.put("type", "eventual");
 655         jsonInsert.setConsistencyInfo(consistencyInfo);
 656         jsonInsert.setKeyspaceName(keyspaceName);
 657         jsonInsert.setTableName(tableName);
 658         jsonInsert.setValues(values);
 659         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 660                 appName, authorization, jsonInsert, "", "");
 661         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 662
 663         assertEquals(400, response.getStatus());
 664     }
 665
 666     @Test
 667     public void test4_insertIntoTable2() throws Exception {
 668         System.out.println("Testing insert into table #2");
 669         createTable();
 670         JsonInsert jsonInsert = new JsonInsert();
 671         Map<String, String> consistencyInfo = new HashMap<>();
 672         Map<String, Object> values = new HashMap<>();
 673         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 674         values.put("emp_name", "test1");
 675         values.put("emp_salary", 1500);
 676         consistencyInfo.put("type", "eventual");
 677         jsonInsert.setConsistencyInfo(consistencyInfo);
 678         jsonInsert.setKeyspaceName(keyspaceName);
 679         jsonInsert.setTableName(tableName);
 680         jsonInsert.setValues(values);
 681         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 682                 authorization, jsonInsert, keyspaceName, tableName);
 683         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 684
 685         assertEquals(200, response.getStatus());
 686     }
 687
 688     // Table wrong
 689     @Test
 690     public void test4_insertIntoTable4() throws Exception {
 691         System.out.println("Testing insert into wrong table");
 692         createTable();
 693         JsonInsert jsonInsert = new JsonInsert();
 694         Map<String, String> consistencyInfo = new HashMap<>();
 695         Map<String, Object> values = new HashMap<>();
 696         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 697         values.put("emp_name", "test1");
 698         values.put("emp_salary", 1500);
 699         consistencyInfo.put("type", "eventual");
 700         jsonInsert.setConsistencyInfo(consistencyInfo);
 701         jsonInsert.setKeyspaceName(keyspaceName);
 702         jsonInsert.setTableName(tableName);
 703         jsonInsert.setValues(values);
 704         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 705                 authorization, jsonInsert, keyspaceName, "wrong");
 706         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 707
 708         assertEquals(400, response.getStatus());
 709     }
 710
 711     @Test
 712     public void test4_insertBlobIntoTable() throws Exception {
 713         System.out.println("Testing insert a blob into table");
 714         createTable();
 715         JsonInsert jsonInsert = new JsonInsert();
 716         Map<String, String> consistencyInfo = new HashMap<>();
 717         Map<String, Object> values = new HashMap<>();
 718         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 719         values.put("emp_name", "testname");
 720         values.put("emp_salary", 500);
 721         values.put("binary", "somestuffhere");
 722         consistencyInfo.put("type", "eventual");
 723         jsonInsert.setConsistencyInfo(consistencyInfo);
 724         jsonInsert.setKeyspaceName(keyspaceName);
 725         jsonInsert.setTableName(tableName);
 726         jsonInsert.setValues(values);
 727         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 728                 authorization, jsonInsert, keyspaceName, tableName);
 729         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 730
 731         assertEquals(200, response.getStatus());
 732     }
 733
 734     @Test
 735     public void test5_updateTable() throws Exception {
 736         System.out.println("Testing update table");
 737         createTable();
 738
 739         JsonUpdate jsonUpdate = new JsonUpdate();
 740         Map<String, String> consistencyInfo = new HashMap<>();
 741         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 742         Map<String, Object> values = new HashMap<>();
 743         row.add("emp_name", "testname");
 744         values.put("emp_salary", 2500);
 745         consistencyInfo.put("type", "atomic");
 746         jsonUpdate.setConsistencyInfo(consistencyInfo);
 747         jsonUpdate.setKeyspaceName(keyspaceName);
 748         jsonUpdate.setTableName(tableName);
 749         jsonUpdate.setValues(values);
 750         Mockito.when(info.getQueryParameters()).thenReturn(row);
 751         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 752                 authorization, jsonUpdate, keyspaceName, tableName, info);
 753
 754         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 755
 756         assertEquals(200, response.getStatus());
 757     }
 758
 759
 760     public void test5_updateTableNoBody() throws Exception {
 761         System.out.println("Testing update table no body");
 762         createTable();
 763
 764         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 765                 authorization, null, keyspaceName, tableName, info);
 766
 767         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 768
 769         assertEquals(400, response.getStatus());
 770     }
 771
 772     @Test
 773     public void test5_updateTable_tableDNE() throws Exception {
 774         System.out.println("Testing update table that does not exist");
 775         createTable();
 776
 777         JsonUpdate jsonUpdate = new JsonUpdate();
 778         Map<String, String> consistencyInfo = new HashMap<>();
 779         Map<String, Object> values = new HashMap<>();
 780         values.put("emp_salary", 2500);
 781         consistencyInfo.put("type", "atomic");
 782         jsonUpdate.setConsistencyInfo(consistencyInfo);
 783         jsonUpdate.setKeyspaceName(keyspaceName);
 784         jsonUpdate.setTableName("wrong_"+tableName);
 785         jsonUpdate.setValues(values);
 786         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 787                 authorization, jsonUpdate, keyspaceName, "wrong_"+ tableName, info);
 788
 789         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 790
 791         assertEquals(400, response.getStatus());
 792     }
 793
 794     @Test
 795     public void test5_updateTableNoName() throws Exception {
 796         System.out.println("Testing update table without tablename");
 797         createTable();
 798
 799         JsonUpdate jsonUpdate = new JsonUpdate();
 800         Map<String, String> consistencyInfo = new HashMap<>();
 801         Map<String, Object> values = new HashMap<>();
 802         values.put("emp_salary", 2500);
 803         consistencyInfo.put("type", "atomic");
 804         jsonUpdate.setConsistencyInfo(consistencyInfo);
 805         jsonUpdate.setKeyspaceName(keyspaceName);
 806         jsonUpdate.setTableName(tableName);
 807         jsonUpdate.setValues(values);
 808         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 809                 authorization, jsonUpdate, "", "", info);
 810
 811         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 812
 813         assertEquals(400, response.getStatus());
 814     }
 815
 816     // need mock code to create error for MusicCore methods
 817     @Test
 818     public void test5_updateTableAuthE() throws Exception {
 819         System.out.println("Testing update table #2");
 820         createTable();
 821         // MockitoAnnotations.initMocks(this);
 822         JsonUpdate jsonUpdate = new JsonUpdate();
 823         Map<String, String> consistencyInfo = new HashMap<>();
 824         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 825         Map<String, Object> values = new HashMap<>();
 826         row.add("emp_name", "testname");
 827         values.put("emp_salary", 2500);
 828         consistencyInfo.put("type", "atomic");
 829         jsonUpdate.setConsistencyInfo(consistencyInfo);
 830         jsonUpdate.setKeyspaceName(keyspaceName);
 831         jsonUpdate.setTableName(tableName);
 832         jsonUpdate.setValues(values);
 833         // add ttl & timestamp
 834         // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 835         Mockito.when(info.getQueryParameters()).thenReturn(row);
 836         // Map<String, Object> m1= new HashMap<>() ;
 837         // Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
 838         Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 839                 authorization, jsonUpdate, keyspaceName, tableName, info);
 840         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 841
 842         assertEquals(200, response.getStatus());
 843     }
 844
 845         @Test
 846         public void test6_critical_selectAtomic() throws Exception {
 847                 System.out.println("Testing critical select atomic");
 848                 createAndInsertIntoTable();
 849                 JsonInsert jsonInsert = new JsonInsert();
 850                 Map<String, String> consistencyInfo = new HashMap<>();
 851                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 852                 row.add("emp_name", "testname");
 853                 consistencyInfo.put("type", "atomic");
 854                 jsonInsert.setConsistencyInfo(consistencyInfo);
 855                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 856                 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 857                                 appName, authorization, jsonInsert, keyspaceName, tableName,info);
 858                 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 859                 HashMap<String, Object> result = map.get("result");
 860                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 861
 862                 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
 863                 assertEquals("testname", row0.get("emp_name"));
 864                 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
 865         }
 866
 867
 868         @Test
 869     public void test6_critical_select() throws Exception {
 870         System.out.println("Testing critical select w/o body");
 871         createAndInsertIntoTable();
 872         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 873         row.add("emp_name", "testname");
 874         Mockito.when(info.getQueryParameters()).thenReturn(row);
 875         Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 876                 appName, authorization, null, keyspaceName, tableName,info);
 877         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 878         HashMap<String, Object> result = map.get("result");
 879         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 880
 881         assertEquals(400, response.getStatus());
 882     }
 883
 884     // Added during merge?
 885         @Test
 886     public void test6_critical_selectCritical_nolockid() throws Exception {
 887         System.out.println("Testing critical select critical w/o lockid");
 888         createAndInsertIntoTable();
 889         JsonInsert jsonInsert = new JsonInsert();
 890         Map<String, String> consistencyInfo = new HashMap<>();
 891         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 892         row.add("emp_name", "testname");
 893         consistencyInfo.put("type", "critical");
 894         jsonInsert.setConsistencyInfo(consistencyInfo);
 895         Mockito.when(info.getQueryParameters()).thenReturn(row);
 896         Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 897                 appName, authorization, jsonInsert, keyspaceName, tableName,info);
 898         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 899         HashMap<String, Object> result = map.get("result");
 900         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 901
 902         assertEquals(400, response.getStatus());
 903     }
 904
 905         @Test
 906     public void test6_critical_select_nulltable() throws Exception {
 907         System.out.println("Testing critical select w/ null tablename");
 908         createAndInsertIntoTable();
 909         JsonInsert jsonInsert = new JsonInsert();
 910         Map<String, String> consistencyInfo = new HashMap<>();
 911         consistencyInfo.put("type", "atomic");
 912         jsonInsert.setConsistencyInfo(consistencyInfo);
 913         Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 914                 appName, authorization, jsonInsert, keyspaceName, null,info);
 915         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 916
 917         assertEquals(400, response.getStatus());
 918     }
 919
 920     @Test
 921     public void test6_select() throws Exception {
 922         System.out.println("Testing select");
 923         createAndInsertIntoTable();
 924         JsonSelect jsonSelect = new JsonSelect();
 925         Map<String, String> consistencyInfo = new HashMap<>();
 926         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 927         row.add("emp_name", "testname");
 928         consistencyInfo.put("type", "atomic");
 929         jsonSelect.setConsistencyInfo(consistencyInfo);
 930         Mockito.when(info.getQueryParameters()).thenReturn(row);
 931         Response response = data.selectWithCritical("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 932                 null,keyspaceName, tableName, info);
 933         HashMap<String, HashMap<String, Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 934         HashMap<String, Object> result = map.get("result");
 935         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 936
 937         Map<String, String> row0 = (Map<String, String>) result.get("row 0");
 938         assertEquals("testname", row0.get("emp_name"));
 939         assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
 940     }
 941
 942     @Test
 943     public void test6_select_nullTablename() throws Exception {
 944         System.out.println("Testing select w/ null tablename");
 945         createAndInsertIntoTable();
 946         JsonSelect jsonSelect = new JsonSelect();
 947         Map<String, String> consistencyInfo = new HashMap<>();
 948         consistencyInfo.put("type", "atomic");
 949         jsonSelect.setConsistencyInfo(consistencyInfo);
 950         Response response = data.selectWithCritical("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 951                 appName, wrongAuthorization,null, keyspaceName, null, info);
 952         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 953
 954         assertEquals(400, response.getStatus());
 955     }
 956
 957     @Test
 958     public void test6_deleteFromTable() throws Exception {
 959         System.out.println("Testing delete from table");
 960         createAndInsertIntoTable();
 961         JsonDelete jsonDelete = new JsonDelete();
 962         Map<String, String> consistencyInfo = new HashMap<>();
 963         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 964         row.add("emp_name", "test1");
 965         consistencyInfo.put("type", "atomic");
 966         jsonDelete.setConsistencyInfo(consistencyInfo);
 967         Mockito.when(info.getQueryParameters()).thenReturn(row);
 968         Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 969                 authorization, jsonDelete, keyspaceName, tableName, info);
 970         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 971         assertEquals(200, response.getStatus());
 972     }
 973
 974     @Test
 975     public void test6_deleteFromTable_missingTablename() throws Exception {
 976         System.out.println("Testing delete from table w/ null tablename");
 977         createAndInsertIntoTable();
 978         JsonDelete jsonDelete = new JsonDelete();
 979         Map<String, String> consistencyInfo = new HashMap<>();
 980         consistencyInfo.put("type", "atomic");
 981         jsonDelete.setConsistencyInfo(consistencyInfo);
 982         Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 983                 wrongAuthorization, jsonDelete, keyspaceName, null, info);
 984         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 985         assertEquals(400, response.getStatus());
 986     }
 987
 988     // Values
 989     @Ignore
 990     @Test
 991     public void test6_deleteFromTable1() throws Exception {
 992         System.out.println("Testing delete from table missing delete object");
 993         createAndInsertIntoTable();
 994
 995         JsonDelete jsonDelete = new JsonDelete();
 996         Map<String, String> consistencyInfo = new HashMap<>();
 997         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 998         consistencyInfo.put("type", "atomic");
 999         jsonDelete.setConsistencyInfo(consistencyInfo);
1000         Mockito.when(info.getQueryParameters()).thenReturn(row);
1001         Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1002                 authorization, jsonDelete, keyspaceName, tableName, info);
1003         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1004
1005         assertEquals(400, response.getStatus());
1006     }
1007
1008     // delObj
1009     @Test
1010     public void test6_deleteFromTable2() throws Exception {
1011         System.out.println("Testing delete from table missing delete object");
1012         createAndInsertIntoTable();
1013         JsonDelete jsonDelete = new JsonDelete();
1014         Map<String, String> consistencyInfo = new HashMap<>();
1015         consistencyInfo.put("type", "atomic");
1016         jsonDelete.setConsistencyInfo(consistencyInfo);
1017         Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1018                 authorization, null, keyspaceName, tableName, info);
1019         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1020
1021         assertEquals(400, response.getStatus());
1022     }
1023
1024     @Test
1025     public void test7_dropTable() throws Exception {
1026         System.out.println("Testing drop table");
1027         createTable();
1028         JsonTable jsonTable = new JsonTable();
1029         Map<String, String> consistencyInfo = new HashMap<>();
1030         consistencyInfo.put("type", "atomic");
1031         jsonTable.setConsistencyInfo(consistencyInfo);
1032         Response response = data.dropTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1033                 authorization, keyspaceName, tableName);
1034         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1035
1036         assertEquals(200, response.getStatus());
1037     }
1038
1039     @Test
1040     public void test7_dropTable_nullTablename() throws Exception {
1041         System.out.println("Testing drop table w/ null tablename");
1042         createTable();
1043         JsonTable jsonTable = new JsonTable();
1044         Map<String, String> consistencyInfo = new HashMap<>();
1045         consistencyInfo.put("type", "atomic");
1046         jsonTable.setConsistencyInfo(consistencyInfo);
1047         Response response = data.dropTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1048                 authorization, keyspaceName, null);
1049         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1050
1051         assertEquals(400, response.getStatus());
1052     }
1053
1054
1055     @Test
1056     public void test8_deleteKeyspace() throws Exception {
1057         System.out.println("Testing drop keyspace");
1058
1059         JsonKeySpace jsonKeyspace = new JsonKeySpace();
1060         Map<String, String> consistencyInfo = new HashMap<>();
1061         Map<String, Object> replicationInfo = new HashMap<>();
1062         consistencyInfo.put("type", "eventual");
1063         replicationInfo.put("class", "SimpleStrategy");
1064         replicationInfo.put("replication_factor", 1);
1065         jsonKeyspace.setConsistencyInfo(consistencyInfo);
1066         jsonKeyspace.setDurabilityOfWrites("true");
1067         jsonKeyspace.setKeyspaceName("TestApp1");
1068         jsonKeyspace.setReplicationInfo(replicationInfo);
1069         Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,
1070                 appName, keyspaceName);
1071         System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1072
1073         assertEquals(400, response.getStatus());
1074     }
1075
1076     private static void createKeyspace() throws Exception {
1077         // shouldn't really be doing this here, but create keyspace is currently turned off
1078         PreparedQueryObject query = new PreparedQueryObject();
1079         query.appendQueryString(CassandraCQL.createKeySpace);
1080         MusicCore.eventualPut(query);
1081
1082         boolean isAAF = false;
1083         String hashedpwd = BCrypt.hashpw(password, BCrypt.gensalt());
1084         query = new PreparedQueryObject();
1085         query.appendQueryString("INSERT into admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
1086                 + "password, username, is_aaf) values (?,?,?,?,?,?,?)");
1087         query.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
1088         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), keyspaceName));
1089         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
1090         query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
1091         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), hashedpwd));
1092         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
1093         query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
1094         MusicCore.eventualPut(query);
1095     }
1096
1097     private void clearAllTablesFromKeyspace() throws MusicServiceException {
1098         ArrayList<String> tableNames = new ArrayList<>();
1099         PreparedQueryObject query = new PreparedQueryObject();
1100         query.appendQueryString(
1101                 "SELECT table_name FROM system_schema.tables WHERE keyspace_name = '" + keyspaceName + "';");
1102         ResultSet rs = MusicCore.get(query);
1103         for (Row row : rs) {
1104             tableNames.add(row.getString("table_name"));
1105         }
1106         for (String table : tableNames) {
1107             query = new PreparedQueryObject();
1108             query.appendQueryString("DROP TABLE " + keyspaceName + "." + table);
1109             MusicCore.eventualPut(query);
1110         }
1111     }
1112
1113     /**
1114      * Create a table {@link tableName} in {@link keyspaceName}
1115      *
1116      * @throws Exception
1117      */
1118     private void createTable() throws Exception {
1119         JsonTable jsonTable = new JsonTable();
1120         Map<String, String> consistencyInfo = new HashMap<>();
1121         Map<String, String> fields = new HashMap<>();
1122         fields.put("uuid", "text");
1123         fields.put("emp_name", "text");
1124         fields.put("emp_salary", "varint");
1125         fields.put("binary", "blob");
1126         fields.put("PRIMARY KEY", "(emp_name)");
1127         consistencyInfo.put("type", "eventual");
1128         jsonTable.setConsistencyInfo(consistencyInfo);
1129         jsonTable.setKeyspaceName(keyspaceName);
1130         jsonTable.setPrimaryKey("emp_name");
1131         jsonTable.setTableName(tableName);
1132         jsonTable.setFields(fields);
1133         // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1134         Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1135                 authorization, jsonTable, keyspaceName, tableName);
1136     }
1137
1138     /**
1139      * Create table {@link createTable} and insert into said table
1140      *
1141      * @throws Exception
1142      */
1143     private void createAndInsertIntoTable() throws Exception {
1144         createTable();
1145
1146         JsonInsert jsonInsert = new JsonInsert();
1147         Map<String, String> consistencyInfo = new HashMap<>();
1148         Map<String, Object> values = new HashMap<>();
1149         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1150         values.put("emp_name", "testname");
1151         values.put("emp_salary", 500);
1152         values.put("binary", "binarydatahere");
1153         consistencyInfo.put("type", "eventual");
1154         jsonInsert.setConsistencyInfo(consistencyInfo);
1155         jsonInsert.setKeyspaceName(keyspaceName);
1156         jsonInsert.setTableName(tableName);
1157         jsonInsert.setValues(values);
1158         Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1159                 authorization, jsonInsert, keyspaceName, tableName);
1160     }
1161 }