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

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