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

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