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
 157         @Test
 158         public void test3_createTableClusterOrderBad() throws Exception {
 159                 System.out.println("Testing create table bad clustering");
 160                 JsonTable jsonTable = new JsonTable();
 161                 Map<String, String> consistencyInfo = new HashMap<>();
 162                 Map<String, String> fields = new HashMap<>();
 163                 fields.put("uuid", "text");
 164                 fields.put("emp_name", "text");
 165                 fields.put("emp_salary", "varint");
 166                 fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
 167                 consistencyInfo.put("type", "eventual");
 168                 jsonTable.setConsistencyInfo(consistencyInfo);
 169                 jsonTable.setKeyspaceName(keyspaceName);
 170                 jsonTable.setPrimaryKey("emp_name,emp_salary");
 171                 jsonTable.setClusteringOrder("ASC");
 172                 jsonTable.setTableName(tableName);
 173                 jsonTable.setFields(fields);
 174                 Response response = data.createTable("1", "1", "1",
 175                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
 176                                 jsonTable, keyspaceName, tableName);
 177                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 178                 assertEquals(400, response.getStatus());
 179         }
 180
 181         @Test
 182         public void test3_createTable_withPropertiesNotNull() throws Exception {
 183                 System.out.println("Testing create table with properties");
 184                 JsonTable jsonTable = new JsonTable();
 185                 Map<String, String> consistencyInfo = new HashMap<>();
 186                 Map<String, String> fields = new HashMap<>();
 187                 fields.put("uuid", "text");
 188                 fields.put("emp_name", "text");
 189                 fields.put("emp_salary", "varint");
 190                 fields.put("PRIMARY KEY", "(emp_name)");
 191                 consistencyInfo.put("type", "eventual");
 192                 Map<String, Object> properties = new HashMap<>();
 193                 properties.put("comment","Testing prperties not null");
 194                 jsonTable.setConsistencyInfo(consistencyInfo);
 195                 jsonTable.setKeyspaceName(keyspaceName);
 196                 jsonTable.setPrimaryKey("emp_name");
 197                 String tableName_prop=tableName+"_Prop";
 198                 jsonTable.setTableName(tableName_prop);
 199                 jsonTable.setFields(fields);
 200                 jsonTable.setProperties(properties);
 201
 202                 Response response = data.createTable("1", "1", "1",
 203                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
 204                                 jsonTable, keyspaceName, tableName_prop);
 205                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 206                 assertEquals(200, response.getStatus());
 207         }
 208
 209         @Test
 210         public void test3_createTable_duplicateTable() throws Exception {
 211                 System.out.println("Testing creating duplicate tables");
 212                 JsonTable jsonTable = new JsonTable();
 213                 Map<String, String> consistencyInfo = new HashMap<>();
 214                 Map<String, String> fields = new HashMap<>();
 215                 fields.put("uuid", "text");
 216                 fields.put("emp_name", "text");
 217                 fields.put("emp_salary", "varint");
 218                 fields.put("PRIMARY KEY", "(emp_name)");
 219                 consistencyInfo.put("type", "eventual");
 220                 jsonTable.setConsistencyInfo(consistencyInfo);
 221                 jsonTable.setKeyspaceName(keyspaceName);
 222                 jsonTable.setPrimaryKey("emp_name");
 223                 String tableNameDup=tableName+"x";
 224                 jsonTable.setTableName(tableNameDup);
 225                 jsonTable.setFields(fields);
 226                 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 227                 Response response1 = data.createTable("1", "1", "1",
 228                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 229                                 jsonTable, keyspaceName, tableNameDup);
 230
 231                 Response response2 = data.createTable("1", "1", "1",
 232                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 233                                 jsonTable, keyspaceName, tableNameDup);
 234                 System.out.println("Status: " + response2.getStatus() + ". Entity " + response2.getEntity());
 235
 236                 assertEquals(400, response2.getStatus());
 237                 Map<String,String> respMap = (Map<String, String>) response2.getEntity();
 238                 assertEquals(ResultType.FAILURE, respMap.get("status"));
 239                 assertEquals("Table " + keyspaceName + "." + tableNameDup + " already exists",
 240                                 respMap.get("error"));
 241         }
 242
 243         // Improper Auth
 244         @Test
 245         public void test3_createTable1() throws Exception {
 246                 System.out.println("Testing create table w/ improper authentication");
 247                 JsonTable jsonTable = new JsonTable();
 248                 Map<String, String> consistencyInfo = new HashMap<>();
 249                 Map<String, String> fields = new HashMap<>();
 250                 fields.put("uuid", "text");
 251                 fields.put("emp_name", "text");
 252                 fields.put("emp_salary", "varint");
 253                 fields.put("PRIMARY KEY", "(emp_name)");
 254                 consistencyInfo.put("type", "eventual");
 255                 jsonTable.setConsistencyInfo(consistencyInfo);
 256                 jsonTable.setKeyspaceName(keyspaceName);
 257                 jsonTable.setPrimaryKey("emp_name");
 258                 jsonTable.setTableName(tableName);
 259                 jsonTable.setFields(fields);
 260                 Response response = data.createTable("1", "1", "1",
 261                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
 262                                 jsonTable, keyspaceName, tableName);
 263                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 264                 assertEquals(401, response.getStatus());
 265         }
 266
 267         // Improper keyspace
 268         @Test
 269         public void test3_createTable3() throws Exception {
 270                 System.out.println("Testing create table for wrong keyspace");
 271                 JsonTable jsonTable = new JsonTable();
 272                 Map<String, String> consistencyInfo = new HashMap<>();
 273                 Map<String, String> fields = new HashMap<>();
 274                 fields.put("uuid", "text");
 275                 fields.put("emp_name", "text");
 276                 fields.put("emp_salary", "varint");
 277                 fields.put("PRIMARY KEY", "(emp_name)");
 278                 consistencyInfo.put("type", "eventual");
 279                 jsonTable.setConsistencyInfo(consistencyInfo);
 280                 jsonTable.setKeyspaceName(keyspaceName);
 281                 jsonTable.setPrimaryKey("emp_name");
 282                 jsonTable.setTableName(tableName);
 283                 jsonTable.setFields(fields);
 284                 Response response = data.createTable("1", "1", "1",
 285                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 286                                 jsonTable, "wrong", tableName);
 287                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 288                 assertEquals(401, response.getStatus());
 289         }
 290
 291         // Improper parenthesis in key field
 292         @Test
 293         public void test3_createTable_badParantesis() throws Exception {
 294                 System.out.println("Testing malformed create table request");
 295                 String tableNameC ="testTable0";
 296                 JsonTable jsonTable = new JsonTable();
 297                 Map<String, String> consistencyInfo = new HashMap<>();
 298                 Map<String, String> fields = new HashMap<>();
 299                 fields.put("uuid", "text");
 300                 fields.put("emp_name", "text");
 301                 fields.put("emp_salary", "varint");
 302                 fields.put("PRIMARY KEY", "(emp_name),emp_id)");
 303                 fields.put("emp_id", "varint");
 304                 consistencyInfo.put("type", "eventual");
 305                 jsonTable.setConsistencyInfo(consistencyInfo);
 306                 jsonTable.setKeyspaceName(keyspaceName);
 307                 jsonTable.setPrimaryKey("emp_name");
 308                 jsonTable.setTableName(tableNameC);
 309                 jsonTable.setClusteringOrder("emp_id Desc");
 310                 jsonTable.setFields(fields);
 311                 Response response = data.createTable("1", "1", "1",
 312                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 313                                 jsonTable, keyspaceName, tableNameC);
 314                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 315
 316                 assertEquals(400, response.getStatus());
 317         }
 318
 319
 320         // good clustering key
 321         @Test
 322         public void test3_createTable_1_clusterKey_good() throws Exception {
 323                 System.out.println("Testing create w/ clusterKey");
 324
 325                 String tableNameC ="testTableC1";
 326                 JsonTable jsonTable = new JsonTable();
 327                 Map<String, String> consistencyInfo = new HashMap<>();
 328                 Map<String, String> fields = new HashMap<>();
 329                 fields.put("uuid", "text");
 330                 fields.put("emp_name", "text");
 331                 fields.put("emp_salary", "varint");
 332                 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 333                 consistencyInfo.put("type", "eventual");
 334                 jsonTable.setConsistencyInfo(consistencyInfo);
 335                 jsonTable.setKeyspaceName(keyspaceName);
 336                 // jsonTable.setPrimaryKey("emp_name");
 337                 jsonTable.setTableName(tableNameC);
 338                 jsonTable.setClusteringOrder("emp_salary ASC");
 339                 jsonTable.setFields(fields);
 340                 Response response = data.createTable("1", "1", "1",
 341                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 342                                 jsonTable, keyspaceName, tableNameC);
 343                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 344
 345                 assertEquals(200, response.getStatus());
 346         }
 347
 348         // bad partition key=clustering key
 349         @Test
 350         public void test3_createTable_2_clusterKey_bad() throws Exception {
 351                 System.out.println("Testing create w/ bad clusterKey");
 352                 String tableNameC ="testTableC2";
 353                 JsonTable jsonTable = new JsonTable();
 354                 Map<String, String> consistencyInfo = new HashMap<>();
 355                 Map<String, String> fields = new HashMap<>();
 356                 fields.put("uuid", "text");
 357                 fields.put("emp_name", "text");
 358                 fields.put("emp_salary", "varint");
 359                 fields.put("PRIMARY KEY", "((emp_name),emp_name)");
 360                 consistencyInfo.put("type", "eventual");
 361                 jsonTable.setConsistencyInfo(consistencyInfo);
 362                 jsonTable.setKeyspaceName(keyspaceName);
 363                 jsonTable.setPrimaryKey("emp_name");  // "PRIMARY KEY" overrides if primaryKey present
 364                 jsonTable.setTableName(tableNameC);
 365                 jsonTable.setClusteringOrder("emp_salary ASC");
 366                 jsonTable.setFields(fields);
 367                 Response response = data.createTable("1", "1", "1",
 368                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 369                                 jsonTable, keyspaceName, tableNameC);
 370                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 371
 372                 assertEquals(400, response.getStatus());
 373         }
 374
 375         // good composite partition key,clustering key
 376         @Test
 377         public void test3_createTable_3_pfartition_clusterKey_good() throws Exception {
 378                 System.out.println("Testing create w/ composite partition key, clusterKey");
 379
 380                 String tableNameC ="testTableC3";
 381                 JsonTable jsonTable = new JsonTable();
 382                 Map<String, String> consistencyInfo = new HashMap<>();
 383                 Map<String, String> fields = new HashMap<>();
 384                 fields.put("uuid", "text");
 385                 fields.put("emp_name", "text");
 386                 fields.put("emp_id", "varint");
 387                 fields.put("emp_salary", "varint");
 388                 fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
 389                 consistencyInfo.put("type", "eventual");
 390                 jsonTable.setConsistencyInfo(consistencyInfo);
 391                 jsonTable.setKeyspaceName(keyspaceName);
 392                 jsonTable.setPrimaryKey("emp_name");
 393                 jsonTable.setTableName(tableNameC);
 394                 jsonTable.setClusteringOrder("emp_salary ASC");
 395                 jsonTable.setFields(fields);
 396                 Response response = data.createTable("1", "1", "1",
 397                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 398                                 jsonTable, keyspaceName, tableNameC);
 399                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 400
 401                 assertEquals(200, response.getStatus());
 402         }
 403
 404         // bad - wrong cols in order by of composite partition key,clustering key
 405         @Test
 406         public void test3_createTable_5_clusteringOrder_bad() throws Exception {
 407                 System.out.println("Testing create table bad request with clustering & composite keys");
 408                 String tableNameC ="testTableC5";
 409                 JsonTable jsonTable = new JsonTable();
 410                 Map<String, String> consistencyInfo = new HashMap<>();
 411                 Map<String, String> fields = new HashMap<>();
 412                 fields.put("uuid", "text");
 413                 fields.put("emp_name", "text");
 414                 fields.put("emp_id", "varint");
 415                 fields.put("emp_salary", "varint");
 416                 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
 417                 consistencyInfo.put("type", "eventual");
 418                 jsonTable.setConsistencyInfo(consistencyInfo);
 419                 jsonTable.setKeyspaceName(keyspaceName);
 420                 jsonTable.setPrimaryKey("emp_name");
 421                 jsonTable.setTableName(tableNameC);
 422                 jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
 423                 jsonTable.setFields(fields);
 424                 Response response = data.createTable("1", "1", "1",
 425                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 426                                 jsonTable, keyspaceName, tableNameC);
 427                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 428
 429                 assertEquals(400, response.getStatus());
 430         }
 431
 432
 433         // good clustering key, need to pass queryparameter
 434         @Test
 435         public void test3_createTableIndex_1() throws Exception {
 436                 System.out.println("Testing index in create table");
 437                 String tableNameC ="testTableCinx";
 438                 JsonTable jsonTable = new JsonTable();
 439                 Map<String, String> consistencyInfo = new HashMap<>();
 440                 Map<String, String> fields = new HashMap<>();
 441                 fields.put("uuid", "text");
 442                 fields.put("emp_name", "text");
 443                 fields.put("emp_salary", "varint");
 444                 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
 445                 consistencyInfo.put("type", "eventual");
 446                 jsonTable.setConsistencyInfo(consistencyInfo);
 447                 jsonTable.setKeyspaceName(keyspaceName);
 448                 jsonTable.setTableName(tableNameC);
 449                 jsonTable.setClusteringOrder("emp_salary ASC");
 450                 jsonTable.setFields(fields);
 451                 Response response = data.createTable("1", "1", "1",
 452                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 453                                 jsonTable, keyspaceName, tableNameC);
 454                 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
 455                 // info.setQueryParameters("index_name=inx_uuid");
 456                 Map<String,String> queryParametersMap =new HashMap<String, String>();
 457
 458                 queryParametersMap.put("index_name","inxuuid");
 459                 Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedHashMap<String, String>(queryParametersMap));
 460                 response = data.createIndex("1", "1", "1",
 461                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 462                                 keyspaceName, tableNameC,"uuid",info);
 463                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 464
 465                 assertEquals(200, response.getStatus());
 466         }
 467
 468         @Test
 469         public void test4_insertIntoTable() throws Exception {
 470                 System.out.println("Testing insert into table");
 471                 createTable();
 472                 JsonInsert jsonInsert = new JsonInsert();
 473                 Map<String, String> consistencyInfo = new HashMap<>();
 474                 Map<String, Object> values = new HashMap<>();
 475                 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 476                 values.put("emp_name", "testname");
 477                 values.put("emp_salary", 500);
 478                 consistencyInfo.put("type", "eventual");
 479                 jsonInsert.setConsistencyInfo(consistencyInfo);
 480                 jsonInsert.setKeyspaceName(keyspaceName);
 481                 jsonInsert.setTableName(tableName);
 482                 jsonInsert.setValues(values);
 483                 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 484                                 appName, authorization, jsonInsert, keyspaceName, tableName);
 485                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 486
 487                 assertEquals(200, response.getStatus());
 488         }
 489
 490         @Test
 491         public void test4_insertIntoTable2() throws Exception {
 492                 System.out.println("Testing insert into table #2");
 493                 createTable();
 494                 JsonInsert jsonInsert = new JsonInsert();
 495                 Map<String, String> consistencyInfo = new HashMap<>();
 496                 Map<String, Object> values = new HashMap<>();
 497                 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 498                 values.put("emp_name", "test1");
 499                 values.put("emp_salary", 1500);
 500                 consistencyInfo.put("type", "eventual");
 501                 jsonInsert.setConsistencyInfo(consistencyInfo);
 502                 jsonInsert.setKeyspaceName(keyspaceName);
 503                 jsonInsert.setTableName(tableName);
 504                 jsonInsert.setValues(values);
 505                 Response response = data.insertIntoTable("1", "1", "1",
 506                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 507                                 jsonInsert, keyspaceName, tableName);
 508                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 509
 510                 assertEquals(200, response.getStatus());
 511         }
 512
 513         // Auth Error
 514         @Test
 515         public void test4_insertIntoTable3() throws Exception {
 516                 System.out.println("Testing insert into table with bad credentials");
 517                 createTable();
 518                 JsonInsert jsonInsert = new JsonInsert();
 519                 Map<String, String> consistencyInfo = new HashMap<>();
 520                 Map<String, Object> values = new HashMap<>();
 521                 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 522                 values.put("emp_name", "test1");
 523                 values.put("emp_salary", 1500);
 524                 consistencyInfo.put("type", "eventual");
 525                 jsonInsert.setConsistencyInfo(consistencyInfo);
 526                 jsonInsert.setKeyspaceName(keyspaceName);
 527                 jsonInsert.setTableName(tableName);
 528                 jsonInsert.setValues(values);
 529                 Response response = data.insertIntoTable("1", "1", "1",
 530                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
 531                                 jsonInsert, keyspaceName, tableName);
 532                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 533
 534                 assertEquals(401, response.getStatus());
 535         }
 536
 537         // Table wrong
 538         @Test
 539         public void test4_insertIntoTable4() throws Exception {
 540                 System.out.println("Testing insert into wrong table");
 541                 createTable();
 542                 JsonInsert jsonInsert = new JsonInsert();
 543                 Map<String, String> consistencyInfo = new HashMap<>();
 544                 Map<String, Object> values = new HashMap<>();
 545                 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 546                 values.put("emp_name", "test1");
 547                 values.put("emp_salary", 1500);
 548                 consistencyInfo.put("type", "eventual");
 549                 jsonInsert.setConsistencyInfo(consistencyInfo);
 550                 jsonInsert.setKeyspaceName(keyspaceName);
 551                 jsonInsert.setTableName(tableName);
 552                 jsonInsert.setValues(values);
 553                 Response response = data.insertIntoTable("1", "1", "1",
 554                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 555                                 jsonInsert, keyspaceName, "wrong");
 556                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 557
 558                 assertEquals(400, response.getStatus());
 559         }
 560
 561
 562         @Test
 563         public void test5_updateTable() throws Exception {
 564                 System.out.println("Testing update table");
 565                 createTable();
 566
 567                 JsonUpdate jsonUpdate = new JsonUpdate();
 568                 Map<String, String> consistencyInfo = new HashMap<>();
 569                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 570                 Map<String, Object> values = new HashMap<>();
 571                 row.add("emp_name", "testname");
 572                 values.put("emp_salary", 2500);
 573                 consistencyInfo.put("type", "atomic");
 574                 jsonUpdate.setConsistencyInfo(consistencyInfo);
 575                 jsonUpdate.setKeyspaceName(keyspaceName);
 576                 jsonUpdate.setTableName(tableName);
 577                 jsonUpdate.setValues(values);
 578                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 579                 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 580                                 authorization, jsonUpdate, keyspaceName, tableName, info);
 581
 582                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 583
 584                 assertEquals(200, response.getStatus());
 585         }
 586
 587         // need mock code to create error for MusicCore methods
 588         @Test
 589         public void test5_updateTableAuthE() throws Exception {
 590                 System.out.println("Testing update table #2");
 591                 createTable();
 592                 //MockitoAnnotations.initMocks(this);
 593                 JsonUpdate jsonUpdate = new JsonUpdate();
 594                 Map<String, String> consistencyInfo = new HashMap<>();
 595                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 596                 Map<String, Object> values = new HashMap<>();
 597                 row.add("emp_name", "testname");
 598                 values.put("emp_salary", 2500);
 599                 consistencyInfo.put("type", "atomic");
 600                 jsonUpdate.setConsistencyInfo(consistencyInfo);
 601                 jsonUpdate.setKeyspaceName(keyspaceName);
 602                 jsonUpdate.setTableName(tableName);
 603                 jsonUpdate.setValues(values);
 604                 //add ttl & timestamp
 605                 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 606                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 607                 //Map<String, Object> m1= new HashMap<>() ;
 608                 //Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
 609                 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 610                                 authorization, jsonUpdate, keyspaceName, tableName, info);
 611                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 612
 613                 assertEquals(200, response.getStatus());
 614         }
 615
 616         @Ignore
 617         @Test
 618         public void test5_updateTableAuthException1() throws Exception {
 619                 System.out.println("Testing update table authentication error");
 620                 createTable();
 621                 JsonUpdate jsonUpdate = new JsonUpdate();
 622                 Map<String, String> consistencyInfo = new HashMap<>();
 623                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 624                 Map<String, Object> values = new HashMap<>();
 625                 row.add("emp_name", "testname");
 626                 values.put("emp_salary", 2500);
 627                 consistencyInfo.put("type", "atomic");
 628                 jsonUpdate.setConsistencyInfo(consistencyInfo);
 629                 jsonUpdate.setKeyspaceName(keyspaceName);
 630                 jsonUpdate.setTableName(tableName);
 631                 jsonUpdate.setValues(values);
 632
 633                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 634                 String authDatax = ":";
 635                 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
 636                 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 637                                 authorizationx, jsonUpdate, keyspaceName, tableName, info);
 638                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 639
 640                 assertEquals(401, response.getStatus());
 641         }
 642
 643         @Ignore
 644         @Test
 645         public void test5_updateTableAuthEmpty() throws Exception {
 646                 System.out.println("Testing update table without authentication");
 647                 createTable();
 648
 649                 JsonUpdate jsonUpdate = new JsonUpdate();
 650                 Map<String, String> consistencyInfo = new HashMap<>();
 651                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 652                 Map<String, Object> values = new HashMap<>();
 653                 row.add("emp_name", "testname");
 654                 values.put("emp_salary", 2500);
 655                 consistencyInfo.put("type", "atomic");
 656                 jsonUpdate.setConsistencyInfo(consistencyInfo);
 657                 jsonUpdate.setKeyspaceName(keyspaceName);
 658                 jsonUpdate.setTableName(tableName);
 659                 jsonUpdate.setValues(values);
 660
 661                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 662                 String authDatax =":"+password;
 663                 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
 664                 String appNamex="xx";
 665                 Response response = data.updateTable("1", "1", "1", "", appNamex,
 666                                 authorizationx, jsonUpdate, keyspaceName, tableName, info);
 667                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 668
 669                 assertEquals(401, response.getStatus());
 670         }
 671
 672
 673         @Test
 674         public void test6_select() throws Exception {
 675                 System.out.println("Testing select");
 676                 createAndInsertIntoTable();
 677                 JsonSelect jsonSelect = new JsonSelect();
 678                 Map<String, String> consistencyInfo = new HashMap<>();
 679                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 680                 row.add("emp_name", "testname");
 681                 consistencyInfo.put("type", "atomic");
 682                 jsonSelect.setConsistencyInfo(consistencyInfo);
 683                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 684                 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 685                                 appName, authorization, keyspaceName, tableName, info);
 686                 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 687                 HashMap<String, Object> result = map.get("result");
 688                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 689
 690                 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
 691                 assertEquals("testname", row0.get("emp_name"));
 692                 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
 693         }
 694
 695         @Test
 696         public void test6_selectCritical() throws Exception {
 697                 System.out.println("Testing select critical");
 698                 createAndInsertIntoTable();
 699                 JsonInsert jsonInsert = new JsonInsert();
 700                 Map<String, String> consistencyInfo = new HashMap<>();
 701                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 702                 row.add("emp_name", "testname");
 703                 consistencyInfo.put("type", "atomic");
 704                 jsonInsert.setConsistencyInfo(consistencyInfo);
 705                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 706                 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 707                                 appName, authorization, jsonInsert, keyspaceName, tableName,info);
 708                 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 709                 HashMap<String, Object> result = map.get("result");
 710                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 711
 712                 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
 713                 assertEquals("testname", row0.get("emp_name"));
 714                 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
 715         }
 716
 717         @Test
 718         public void test6_deleteFromTable() throws Exception {
 719                 System.out.println("Testing delete from table");
 720                 createAndInsertIntoTable();
 721                 JsonDelete jsonDelete = new JsonDelete();
 722                 Map<String, String> consistencyInfo = new HashMap<>();
 723                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 724                 row.add("emp_name", "test1");
 725                 consistencyInfo.put("type", "atomic");
 726                 jsonDelete.setConsistencyInfo(consistencyInfo);
 727                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 728                 Response response = data.deleteFromTable("1", "1", "1",
 729                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 730                                 jsonDelete, keyspaceName, tableName, info);
 731                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 732
 733                 assertEquals(200, response.getStatus());
 734         }
 735
 736         // Values
 737         @Ignore
 738         @Test
 739         public void test6_deleteFromTable1() throws Exception {
 740                 System.out.println("Testing delete from table missing delete object");
 741                 createAndInsertIntoTable();
 742
 743                 JsonDelete jsonDelete = new JsonDelete();
 744                 Map<String, String> consistencyInfo = new HashMap<>();
 745                 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 746                 consistencyInfo.put("type", "atomic");
 747                 jsonDelete.setConsistencyInfo(consistencyInfo);
 748                 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 749                 Mockito.when(info.getQueryParameters()).thenReturn(row);
 750                 Response response = data.deleteFromTable("1", "1", "1",
 751                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 752                                 jsonDelete, keyspaceName, tableName, info);
 753                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 754
 755                 assertEquals(400, response.getStatus());
 756         }
 757
 758         // delObj
 759         @Test
 760         public void test6_deleteFromTable2() throws Exception {
 761                 System.out.println("Testing delete from table missing delete object");
 762                 createAndInsertIntoTable();
 763                 JsonDelete jsonDelete = new JsonDelete();
 764                 Map<String, String> consistencyInfo = new HashMap<>();
 765                 consistencyInfo.put("type", "atomic");
 766                 jsonDelete.setConsistencyInfo(consistencyInfo);
 767                 Response response = data.deleteFromTable("1", "1", "1",
 768                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 769                                 null, keyspaceName, tableName, info);
 770                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 771
 772                 assertEquals(400, response.getStatus());
 773         }
 774
 775         @Test
 776         public void test7_dropTable() throws Exception {
 777                 System.out.println("Testing drop table");
 778                 createTable();
 779                 JsonTable jsonTable = new JsonTable();
 780                 Map<String, String> consistencyInfo = new HashMap<>();
 781                 consistencyInfo.put("type", "atomic");
 782                 jsonTable.setConsistencyInfo(consistencyInfo);
 783                 Response response = data.dropTable("1", "1", "1",
 784                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 785                                 keyspaceName, tableName);
 786                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 787
 788                 assertEquals(200, response.getStatus());
 789         }
 790
 791
 792         @Test
 793         public void test8_deleteKeyspace() throws Exception {
 794                 System.out.println("Testing drop keyspace");
 795
 796                 JsonKeySpace jsonKeyspace = new JsonKeySpace();
 797                 Map<String, String> consistencyInfo = new HashMap<>();
 798                 Map<String, Object> replicationInfo = new HashMap<>();
 799                 consistencyInfo.put("type", "eventual");
 800                 replicationInfo.put("class", "SimpleStrategy");
 801                 replicationInfo.put("replication_factor", 1);
 802                 jsonKeyspace.setConsistencyInfo(consistencyInfo);
 803                 jsonKeyspace.setDurabilityOfWrites("true");
 804                 jsonKeyspace.setKeyspaceName("TestApp1");
 805                 jsonKeyspace.setReplicationInfo(replicationInfo);
 806                 Response response = data.dropKeySpace("1", "1", "1",
 807                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,appName, keyspaceName);
 808                 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
 809
 810                 assertEquals(400, response.getStatus());
 811         }
 812
 813         private static void createAdminTable() throws Exception {
 814                 testObject = new PreparedQueryObject();
 815                 testObject.appendQueryString(CassandraCQL.createAdminKeyspace);
 816                 MusicCore.eventualPut(testObject);
 817                 testObject = new PreparedQueryObject();
 818                 testObject.appendQueryString(CassandraCQL.createAdminTable);
 819                 MusicCore.eventualPut(testObject);
 820
 821                 testObject = new PreparedQueryObject();
 822                 testObject.appendQueryString(
 823                                 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
 824                                                 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
 825                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
 826                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
 827                                 MusicUtil.DEFAULTKEYSPACENAME));
 828                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
 829                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
 830                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
 831                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
 832                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
 833                 MusicCore.eventualPut(testObject);
 834
 835                 testObject = new PreparedQueryObject();
 836                 testObject.appendQueryString(
 837                                 "select uuid from admin.keyspace_master where application_name = ? allow filtering");
 838                 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
 839                 ResultSet rs = MusicCore.get(testObject);
 840                 List<Row> rows = rs.all();
 841                 if (rows.size() > 0) {
 842                         System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
 843                 }
 844         }
 845
 846
 847         private static void createKeyspace() throws Exception {
 848                 //shouldn't really be doing this here, but create keyspace is currently turned off
 849                 PreparedQueryObject query = new PreparedQueryObject();
 850                 query.appendQueryString(CassandraCQL.createKeySpace);
 851                 MusicCore.eventualPut(query);
 852
 853                 boolean isAAF = false;
 854         String hashedpwd = BCrypt.hashpw(password, BCrypt.gensalt());
 855         query = new PreparedQueryObject();
 856         query.appendQueryString(
 857                     "INSERT into admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
 858                                     + "password, username, is_aaf) values (?,?,?,?,?,?,?)");
 859         query.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
 860         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), keyspaceName));
 861         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
 862         query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
 863         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), hashedpwd));
 864         query.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
 865         query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
 866         CachingUtil.updateMusicCache(keyspaceName, appName);
 867         CachingUtil.updateMusicValidateCache(appName, userId, hashedpwd);
 868         MusicCore.eventualPut(query);
 869         }
 870
 871         private void clearAllTablesFromKeyspace() throws MusicServiceException {
 872                 ArrayList<String> tableNames = new ArrayList<>();
 873                 PreparedQueryObject query = new PreparedQueryObject();
 874                 query.appendQueryString("SELECT table_name FROM system_schema.tables WHERE keyspace_name = '"+keyspaceName+"';");
 875                 ResultSet rs = MusicCore.get(query);
 876                 for (Row row: rs) {
 877                         tableNames.add(row.getString("table_name"));
 878                 }
 879                 for (String table: tableNames) {
 880                         query = new PreparedQueryObject();
 881                         query.appendQueryString("DROP TABLE " + keyspaceName + "." + table);
 882                         MusicCore.eventualPut(query);
 883                 }
 884         }
 885
 886         /**
 887          * Create a table {@link tableName} in {@link keyspaceName}
 888          * @throws Exception
 889          */
 890         private void createTable() throws Exception {
 891                 JsonTable jsonTable = new JsonTable();
 892                 Map<String, String> consistencyInfo = new HashMap<>();
 893                 Map<String, String> fields = new HashMap<>();
 894                 fields.put("uuid", "text");
 895                 fields.put("emp_name", "text");
 896                 fields.put("emp_salary", "varint");
 897                 fields.put("PRIMARY KEY", "(emp_name)");
 898                 consistencyInfo.put("type", "eventual");
 899                 jsonTable.setConsistencyInfo(consistencyInfo);
 900                 jsonTable.setKeyspaceName(keyspaceName);
 901                 jsonTable.setPrimaryKey("emp_name");
 902                 jsonTable.setTableName(tableName);
 903                 jsonTable.setFields(fields);
 904                 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 905                 Response response = data.createTable("1", "1", "1",
 906                                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
 907                                 jsonTable, keyspaceName, tableName);
 908         }
 909
 910         /**
 911          * Create table {@link createTable} and insert into said table
 912          * @throws Exception
 913          */
 914         private void createAndInsertIntoTable() throws Exception {
 915                 createTable();
 916
 917                 JsonInsert jsonInsert = new JsonInsert();
 918                 Map<String, String> consistencyInfo = new HashMap<>();
 919                 Map<String, Object> values = new HashMap<>();
 920                 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 921                 values.put("emp_name", "testname");
 922                 values.put("emp_salary", 500);
 923                 consistencyInfo.put("type", "eventual");
 924                 jsonInsert.setConsistencyInfo(consistencyInfo);
 925                 jsonInsert.setKeyspaceName(keyspaceName);
 926                 jsonInsert.setTableName(tableName);
 927                 jsonInsert.setValues(values);
 928                 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 929                                 appName, authorization, jsonInsert, keyspaceName, tableName);
 930         }
 931 }