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

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