src/test/java/org/onap/music/unittests/TestRestMusicQAPI.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 //cjc import static org.junit.Assert.assertTrue;
  26 import java.io.File;
  27 import java.net.URI;
  28 import java.net.URISyntaxException;
  29 import java.util.HashMap;
  30 import java.util.List;
  31 //cjc import java.util.List;
  32 import java.util.Map;
  33 import java.util.UUID;
  34 import javax.servlet.http.HttpServletResponse;
  35 import javax.ws.rs.core.MultivaluedMap;
  36 import javax.ws.rs.core.Response;
  37 import javax.ws.rs.core.UriInfo;
  38 import org.junit.After;
  39 import org.junit.AfterClass;
  40 import org.junit.BeforeClass;
  41 import org.junit.FixMethodOrder;
  42 import org.junit.Ignore;
  43 import org.junit.Test;
  44 import org.junit.runner.RunWith;
  45 import org.junit.runners.MethodSorters;
  46 import org.mindrot.jbcrypt.BCrypt;
  47 //cjcimport org.mindrot.jbcrypt.BCrypt;
  48 import org.mockito.Mock;
  49 import org.mockito.Mockito;
  50 import org.mockito.junit.MockitoJUnitRunner;
  51 import org.onap.music.datastore.MusicDataStoreHandle;
  52 import org.onap.music.datastore.PreparedQueryObject;
  53 import org.onap.music.datastore.jsonobjects.JsonDelete;
  54 import org.onap.music.datastore.jsonobjects.JsonInsert;
  55 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
  56 //cjc import org.onap.music.datastore.jsonobjects.JsonKeySpace;
  57 //import org.onap.music.datastore.jsonobjects.JsonOnboard;
  58 import org.onap.music.datastore.jsonobjects.JsonSelect;
  59 import org.onap.music.datastore.jsonobjects.JsonTable;
  60 import org.onap.music.datastore.jsonobjects.JsonUpdate;
  61 import org.onap.music.lockingservice.cassandra.CassaLockStore;
  62 import org.onap.music.main.MusicCore;
  63 import org.onap.music.main.MusicUtil;
  64 //import org.onap.music.main.ResultType;
  65 import org.onap.music.rest.RestMusicAdminAPI;
  66 import org.onap.music.rest.RestMusicDataAPI;
  67 import org.onap.music.rest.RestMusicQAPI;
  68 import org.onap.music.rest.RestMusicLocksAPI;
  69 import com.datastax.driver.core.DataType;
  70 import com.datastax.driver.core.ResultSet;
  71 import com.datastax.driver.core.Row;
  72 import com.sun.jersey.core.util.Base64;
  73 //import com.datastax.driver.core.DataType;
  74 //import com.datastax.driver.core.ResultSet;
  75 //import com.datastax.driver.core.Row;
  76 import com.sun.jersey.core.util.MultivaluedMapImpl;
  77
  78 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  79 @RunWith(MockitoJUnitRunner.class)
  80 public class TestRestMusicQAPI {
  81
  82
  83     RestMusicAdminAPI admin = new RestMusicAdminAPI();
  84     RestMusicLocksAPI lock = new RestMusicLocksAPI();
  85     RestMusicQAPI qData = new RestMusicQAPI();
  86     static PreparedQueryObject testObject;
  87
  88     @Mock
  89     static HttpServletResponse http;
  90
  91     @Mock
  92     UriInfo info;
  93
  94     static String appName = "TestApp";
  95     static String userId = "TestUser";
  96     static String password = "TestPassword";
  97     /*
  98     static String appName = "com.att.ecomp.portal.demeter.aid";//"TestApp";
  99     static String userId = "m00468@portal.ecomp.att.com";//"TestUser";
 100     static String password = "happy123";//"TestPassword";
 101     */
 102     static String authData = userId+":"+password;
 103     static String wrongAuthData = userId+":"+"pass";
 104     static String authorization = new String(Base64.encode(authData.getBytes()));
 105     static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
 106
 107     static boolean isAAF = false;
 108     static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
 109     static String uuidS = "abc66ccc-d857-4e90-b1e5-df98a3d40ce6";
 110     static String keyspaceName = "testkscjc";
 111     static String tableName = "employees";
 112     static String xLatestVersion = "X-latestVersion";
 113     static String onboardUUID = null;
 114     static String lockId = null;
 115     static String lockName = "testkscjc.employees.sample3";
 116     static String majorV="3";
 117     static String minorV="0";
 118     static String patchV="1";
 119     static String aid=null;
 120     static JsonKeySpace kspObject=null;
 121     static RestMusicDataAPI data = new RestMusicDataAPI();
 122     static Response resp;
 123
 124     @BeforeClass
 125     public static void init() throws Exception {
 126         try {
 127             MusicDataStoreHandle.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
 128             MusicCore.mLockHandle = new CassaLockStore(MusicDataStoreHandle.mDstoreHandle);
 129
 130            // System.out.println("before class keysp");
 131             //resp=data.createKeySpace(majorV,minorV,patchV,aid,appName,userId,password,kspObject,keyspaceName);
 132             //System.out.println("after keyspace="+keyspaceName);
 133         } catch (Exception e) {
 134           System.out.println("before class exception ");
 135             e.printStackTrace();
 136         }
 137       // admin keyspace and table
 138         testObject = new PreparedQueryObject();
 139         testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = "
 140                         + "{'class' : 'SimpleStrategy' , "
 141                         + "'replication_factor': 1} AND DURABLE_WRITES = true");
 142         MusicCore.eventualPut(testObject);
 143         testObject = new PreparedQueryObject();
 144         testObject.appendQueryString(
 145                         "CREATE TABLE admin.keyspace_master (" + "  uuid uuid, keyspace_name text,"
 146                                         + "  application_name text, is_api boolean,"
 147                                         + "  password text, username text,"
 148                                         + "  is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
 149         MusicCore.eventualPut(testObject);
 150
 151         testObject = new PreparedQueryObject();
 152         testObject.appendQueryString(
 153                         "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
 154                                         + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
 155         testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
 156         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
 157                         MusicUtil.DEFAULTKEYSPACENAME));
 158         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
 159         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
 160         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
 161         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
 162         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
 163         MusicCore.eventualPut(testObject);
 164
 165         testObject = new PreparedQueryObject();
 166         testObject.appendQueryString(
 167                         "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
 168                                         + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
 169         testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
 170                         UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
 171         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
 172                         MusicUtil.DEFAULTKEYSPACENAME));
 173         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
 174         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
 175         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
 176         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
 177         testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
 178         MusicCore.eventualPut(testObject);
 179
 180         testObject = new PreparedQueryObject();
 181         testObject.appendQueryString(
 182                         "select uuid from admin.keyspace_master where application_name = ? allow filtering");
 183         testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
 184         ResultSet rs = MusicCore.get(testObject);
 185         List<Row> rows = rs.all();
 186         if (rows.size() > 0) {
 187             System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
 188         }
 189
 190         JsonKeySpace jsonKeyspace = new JsonKeySpace();
 191         Map<String, String> consistencyInfo = new HashMap<>();
 192         Map<String, Object> replicationInfo = new HashMap<>();
 193         consistencyInfo.put("type", "eventual");
 194         replicationInfo.put("class", "SimpleStrategy");
 195         replicationInfo.put("replication_factor", 1);
 196         jsonKeyspace.setConsistencyInfo(consistencyInfo);
 197         jsonKeyspace.setDurabilityOfWrites("true");
 198         jsonKeyspace.setKeyspaceName(keyspaceName);
 199         jsonKeyspace.setReplicationInfo(replicationInfo);
 200         Response response = data.createKeySpace(majorV, minorV, patchV, null, authorization, appName,
 201                                     jsonKeyspace, keyspaceName);
 202         System.out.println("#######status is " + response.getStatus()+" keyspace="+keyspaceName);
 203
 204     }
 205
 206     @AfterClass
 207     public static void tearDownAfterClass() throws Exception {
 208         System.out.println("After class");
 209         testObject = new PreparedQueryObject();
 210         testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
 211         MusicCore.eventualPut(testObject);
 212         testObject = new PreparedQueryObject();
 213         testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
 214         MusicCore.eventualPut(testObject);
 215         if (MusicDataStoreHandle.mDstoreHandle!=null) {}
 216             //MusicDataStoreHandle.mDstoreHandle.close();
 217     }
 218
 219
 220 /*    @Test
 221     public void Test1_createQ_good() throws Exception {
 222         JsonTable jsonTable = new JsonTable();
 223         Map<String, String> consistencyInfo = new HashMap<>();
 224         Map<String, String> fields = new HashMap<>();
 225         fields.put("uuid", "text");
 226         fields.put("emp_name", "text");
 227         fields.put("emp_salary", "varint");
 228         consistencyInfo.put("type", "eventual");
 229         jsonTable.setConsistencyInfo(consistencyInfo);
 230         jsonTable.setKeyspaceName(keyspaceName);
 231         jsonTable.setTableName(tableName);
 232         jsonTable.setFields(fields);
 233         jsonTable.setPartitionKey("emp_name");
 234         jsonTable.setClusteringKey("uuid");
 235         jsonTable.setClusteringOrder("uuid ASC");
 236         //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
 237         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 238         Response response = qData.createQ(majorV, minorV,patchV,
 239                         aid, appName, authorization,
 240                         jsonTable, keyspaceName, tableName);
 241         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 242         System.out.println("#######status is " + response.getStatus());
 243         System.out.println("Entity" + response.getEntity());
 244         assertEquals(200, response.getStatus());
 245     }*/
 246
 247     @Test
 248     public void Test1_createQ_FieldsEmpty() throws Exception {
 249         JsonTable jsonTable = new JsonTable();
 250         Map<String, String> consistencyInfo = new HashMap<>();
 251         Map<String, String> fields = new HashMap<>();
 252         /*
 253         fields.put("uuid", "text");
 254         fields.put("emp_name", "text");
 255         fields.put("emp_salary", "varint");
 256         fields.put("PRIMARY KEY", "(emp_name)");
 257         */
 258         consistencyInfo.put("type", "eventual");
 259         jsonTable.setConsistencyInfo(consistencyInfo);
 260         jsonTable.setKeyspaceName(keyspaceName);
 261         jsonTable.setPrimaryKey("emp_name");
 262         jsonTable.setTableName(tableName);
 263         jsonTable.setFields(fields);
 264         //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
 265         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 266         Response response = qData.createQ(majorV, minorV,patchV,
 267                         aid, appName, authorization,
 268                         jsonTable, keyspaceName, tableName);
 269         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 270         System.out.println("EmptyFields #######status is " + response.getStatus());
 271         System.out.println("Entity" + response.getEntity());
 272         assertNotEquals(200, response.getStatus());
 273     }
 274 /*    @Test
 275     public void Test1_createQ_Clustergood() throws Exception {
 276         String tableNameC="testcjcC";
 277         JsonTable jsonTable = new JsonTable();
 278         Map<String, String> consistencyInfo = new HashMap<>();
 279         Map<String, String> fields = new HashMap<>();
 280         fields.put("uuid", "text");
 281         fields.put("emp_name", "text");
 282         fields.put("emp_id", "text");
 283         fields.put("emp_salary", "varint");
 284         consistencyInfo.put("type", "eventual");
 285         jsonTable.setConsistencyInfo(consistencyInfo);
 286         jsonTable.setKeyspaceName(keyspaceName);
 287         jsonTable.setPartitionKey("emp_name");
 288         jsonTable.setClusteringKey("emp_id");
 289         jsonTable.setClusteringOrder("emp_id DESC");
 290         jsonTable.setTableName(tableNameC);
 291         jsonTable.setFields(fields);
 292         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 293         Response response = qData.createQ(majorV, minorV,patchV,
 294                         aid, appName, authorization,
 295                         jsonTable, keyspaceName, tableNameC);
 296         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 297         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 298         System.out.println("Entity" + response.getEntity());
 299         assertEquals(200, response.getStatus());
 300     }*/
 301
 302 /*    @Test
 303     public void Test1_createQ_ClusterOrderGood1() throws Exception {
 304         String tableNameC="testcjcO";
 305         JsonTable jsonTable = new JsonTable();
 306         Map<String, String> consistencyInfo = new HashMap<>();
 307         Map<String, String> fields = new HashMap<>();
 308         fields.put("uuid", "text");
 309         fields.put("emp_name", "text");
 310         fields.put("emp_id", "text");
 311         fields.put("emp_salary", "varint");
 312         fields.put("PRIMARY KEY", "(emp_name,emp_id)");
 313         consistencyInfo.put("type", "eventual");
 314         jsonTable.setConsistencyInfo(consistencyInfo);
 315         jsonTable.setKeyspaceName(keyspaceName);
 316         jsonTable.setTableName(tableNameC);
 317         jsonTable.setClusteringOrder("emp_id DESC");
 318         jsonTable.setFields(fields);
 319         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 320         Response response = qData.createQ(majorV, minorV,patchV,
 321                         aid, appName, authorization,
 322                         jsonTable, keyspaceName, tableNameC);
 323         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 324         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 325         System.out.println("Entity" + response.getEntity());
 326         assertEquals(200, response.getStatus());
 327     } */
 328
 329 /*    @Test
 330     public void Test1_createQ_PartitionKeygood() throws Exception {
 331         String tableNameP="testcjcP";
 332         JsonTable jsonTable = new JsonTable();
 333         Map<String, String> consistencyInfo = new HashMap<>();
 334         Map<String, String> fields = new HashMap<>();
 335         fields.put("uuid", "text");
 336         fields.put("emp_name", "text");
 337         fields.put("emp_id", "text");
 338         fields.put("emp_salary", "varint");
 339         fields.put("PRIMARY KEY", "((emp_name,emp_salary),emp_id)");
 340         consistencyInfo.put("type", "eventual");
 341         jsonTable.setConsistencyInfo(consistencyInfo);
 342         jsonTable.setKeyspaceName(keyspaceName);
 343         jsonTable.setTableName(tableNameP);
 344         jsonTable.setClusteringOrder("emp_id DESC");
 345         jsonTable.setFields(fields);
 346         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 347         Response response = qData.createQ(majorV, minorV,patchV,
 348                         aid, appName, authorization,
 349                         jsonTable, keyspaceName, tableNameP);
 350         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 351         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameP);
 352         System.out.println("Entity" + response.getEntity());
 353         assertEquals(200, response.getStatus());
 354     } */
 355
 356     @Test
 357     public void Test1_createQ_PartitionKeybadclose() throws Exception {
 358         String tableNameC="testcjcP1";
 359         JsonTable jsonTable = new JsonTable();
 360         Map<String, String> consistencyInfo = new HashMap<>();
 361         Map<String, String> fields = new HashMap<>();
 362         fields.put("uuid", "text");
 363         fields.put("emp_name", "text");
 364         fields.put("emp_id", "text");
 365         fields.put("emp_salary", "varint");
 366         fields.put("PRIMARY KEY", "((emp_name,emp_salary),emp_id))");
 367         consistencyInfo.put("type", "eventual");
 368         jsonTable.setConsistencyInfo(consistencyInfo);
 369         jsonTable.setKeyspaceName(keyspaceName);
 370         jsonTable.setPrimaryKey("emp_name,emp_id");
 371         jsonTable.setTableName(tableNameC);
 372         jsonTable.setClusteringOrder("emp_id DESC");
 373         jsonTable.setFields(fields);
 374         //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
 375         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 376         Response response = qData.createQ(majorV, minorV,patchV,
 377                         aid, appName, authorization,
 378                         jsonTable, keyspaceName, tableNameC);
 379         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 380         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 381         System.out.println("Entity" + response.getEntity());
 382         //assertEquals(400, response.getStatus());
 383         assertTrue(200 != response.getStatus());
 384     }
 385
 386 /*    @Test
 387     public void Test1_createQ_ClusterOrderGood2() throws Exception {
 388         String tableNameC="testcjcO1g";
 389         JsonTable jsonTable = new JsonTable();
 390         Map<String, String> consistencyInfo = new HashMap<>();
 391         Map<String, String> fields = new HashMap<>();
 392         fields.put("uuid", "text");
 393         fields.put("emp_name", "text");
 394         fields.put("emp_id", "text");
 395         fields.put("emp_salary", "varint");
 396         fields.put("PRIMARY KEY", "(emp_name,emp_salary,emp_id)");
 397         consistencyInfo.put("type", "eventual");
 398         jsonTable.setConsistencyInfo(consistencyInfo);
 399         jsonTable.setKeyspaceName(keyspaceName);
 400         jsonTable.setPrimaryKey("emp_name,emp_id");
 401         jsonTable.setTableName(tableNameC);
 402         jsonTable.setClusteringOrder("emp_salary ASC,emp_id DESC");
 403         jsonTable.setFields(fields);
 404         //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
 405         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 406         Response response = qData.createQ(majorV, minorV,patchV,
 407                         aid, appName, authorization,
 408                         jsonTable, keyspaceName, tableNameC);
 409         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 410         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 411         System.out.println("Entity" + response.getEntity());
 412         assertEquals(200, response.getStatus());
 413     } */
 414
 415  /*   @Test
 416     public void Test1_createQ_ColPkeyoverridesPrimaryKeyGood() throws Exception {
 417         String tableNameC="testcjcPr";
 418         JsonTable jsonTable = new JsonTable();
 419         Map<String, String> consistencyInfo = new HashMap<>();
 420         Map<String, String> fields = new HashMap<>();
 421         fields.put("uuid", "text");
 422         fields.put("emp_name", "text");
 423         fields.put("emp_id", "text");
 424         fields.put("emp_salary", "varint");
 425         fields.put("PRIMARY KEY", "((emp_name),emp_salary,emp_id)");
 426         consistencyInfo.put("type", "eventual");
 427         jsonTable.setConsistencyInfo(consistencyInfo);
 428         jsonTable.setKeyspaceName(keyspaceName);
 429         jsonTable.setPrimaryKey("emp_name,emp_id");
 430         jsonTable.setTableName(tableNameC);
 431         jsonTable.setClusteringOrder("emp_salary ASC,emp_id DESC");
 432         jsonTable.setFields(fields);
 433         //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
 434         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 435         Response response = qData.createQ(majorV, minorV,patchV,
 436                         aid, appName, authorization,
 437                         jsonTable, keyspaceName, tableNameC);
 438         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 439         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 440         System.out.println("Entity" + response.getEntity());
 441         assertEquals(200, response.getStatus());
 442         //assertTrue(200 != response.getStatus());
 443     } */
 444
 445     @Test
 446     public void Test1_createQ_ClusterOrderBad() throws Exception {
 447         String tableNameC="testcjcO1b";
 448         JsonTable jsonTable = new JsonTable();
 449         Map<String, String> consistencyInfo = new HashMap<>();
 450         Map<String, String> fields = new HashMap<>();
 451         fields.put("uuid", "text");
 452         fields.put("emp_name", "text");
 453         fields.put("emp_id", "text");
 454         fields.put("emp_salary", "varint");
 455         fields.put("PRIMARY KEY", "(emp_name,emp_id)");
 456         consistencyInfo.put("type", "eventual");
 457         jsonTable.setConsistencyInfo(consistencyInfo);
 458         jsonTable.setKeyspaceName(keyspaceName);
 459         jsonTable.setPrimaryKey("emp_name,emp_id");
 460         jsonTable.setTableName(tableNameC);
 461         jsonTable.setClusteringOrder("emp_id DESCx");
 462         jsonTable.setFields(fields);
 463         //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
 464         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 465         Response response = qData.createQ(majorV, minorV,patchV,
 466                         aid, appName, authorization,
 467                         jsonTable, keyspaceName, tableNameC);
 468         //                      "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
 469         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 470         System.out.println("Entity" + response.getEntity());
 471         assertEquals(401, response.getStatus());
 472     }
 473
 474
 475     @Test
 476     public void Test3_createQ_0() throws Exception {
 477          //duplicate testing ...
 478         JsonTable jsonTable = new JsonTable();
 479         Map<String, String> consistencyInfo = new HashMap<>();
 480         Map<String, String> fields = new HashMap<>();
 481         fields.put("uuid", "text");
 482         fields.put("emp_name", "text");
 483         fields.put("emp_salary", "varint");
 484         fields.put("PRIMARY KEY", "(emp_name)");
 485         consistencyInfo.put("type", "eventual");
 486         jsonTable.setConsistencyInfo(consistencyInfo);
 487         jsonTable.setKeyspaceName(keyspaceName);
 488         jsonTable.setPrimaryKey("emp_name");
 489         String tableNameDup=tableName+"X";
 490         jsonTable.setTableName(tableNameDup);
 491         jsonTable.setFields(fields);
 492         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 493         Response response = qData.createQ(majorV, minorV,patchV,
 494                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 495                         jsonTable, keyspaceName, tableNameDup);
 496         System.out.println("#######status for 1st time " + response.getStatus());
 497         System.out.println("Entity" + response.getEntity());
 498
 499         Response response0 = qData.createQ(majorV, minorV,patchV,
 500                 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 501                 jsonTable, keyspaceName, tableNameDup);
 502         // 400 is the duplicate status found in response
 503         // Music 113 duplicate testing
 504         //import static org.junit.Assert.assertNotEquals;
 505         System.out.println("#######status for 2nd time " + response0.getStatus());
 506         System.out.println("Entity" + response0.getEntity());
 507
 508         assertFalse("Duplicate table not created for "+tableNameDup, 200==response0.getStatus());
 509         //assertEquals(400, response0.getStatus());
 510         //assertNotEquals(200,response0.getStatus());
 511     }
 512
 513     // Improper Auth
 514     @Test
 515     public void Test3_createQ1() throws Exception {
 516         JsonTable jsonTable = new JsonTable();
 517         Map<String, String> consistencyInfo = new HashMap<>();
 518         Map<String, String> fields = new HashMap<>();
 519         fields.put("uuid", "text");
 520         fields.put("emp_name", "text");
 521         fields.put("emp_salary", "varint");
 522         fields.put("PRIMARY KEY", "(emp_name)");
 523         consistencyInfo.put("type", "eventual");
 524         jsonTable.setConsistencyInfo(consistencyInfo);
 525         jsonTable.setKeyspaceName(keyspaceName);
 526         jsonTable.setPartitionKey("emp_name");
 527         jsonTable.setClusteringKey("uuid");
 528         jsonTable.setTableName(tableName);
 529         jsonTable.setClusteringOrder("uuid DESC");
 530         jsonTable.setFields(fields);
 531         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 532         Response response = qData.createQ(majorV, minorV,patchV,
 533                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
 534                         jsonTable, keyspaceName, tableName);
 535         System.out.println("#######status is " + response.getStatus());
 536         System.out.println("Entity" + response.getEntity());
 537         assertEquals(401, response.getStatus());
 538     }
 539
 540     // Improper keyspace
 541     @Test
 542     public void Test3_createQ2() throws Exception {
 543         JsonTable jsonTable = new JsonTable();
 544         Map<String, String> consistencyInfo = new HashMap<>();
 545         Map<String, String> fields = new HashMap<>();
 546         fields.put("uuid", "text");
 547         fields.put("emp_name", "text");
 548         fields.put("emp_salary", "varint");
 549         fields.put("PRIMARY KEY", "(emp_name)");
 550         consistencyInfo.put("type", "eventual");
 551         jsonTable.setConsistencyInfo(consistencyInfo);
 552         jsonTable.setKeyspaceName(keyspaceName);
 553         jsonTable.setPartitionKey("emp_name");
 554         jsonTable.setTableName(tableName);
 555         jsonTable.setClusteringKey("emp_salary");
 556         jsonTable.setClusteringOrder("emp_salary DESC");
 557         jsonTable.setFields(fields);
 558         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 559         Response response = qData.createQ(majorV, minorV,patchV,
 560                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 561                         jsonTable, "wrong", tableName);
 562         System.out.println("#######status is " + response.getStatus());
 563         System.out.println("Entity" + response.getEntity());
 564         assertEquals(401, response.getStatus());
 565     }
 566
 567
 568
 569 /*    @Test
 570     public void Test4_insertIntoQ() throws Exception {
 571         JsonInsert jsonInsert = new JsonInsert();
 572         Map<String, String> consistencyInfo = new HashMap<>();
 573         Map<String, Object> values = new HashMap<>();
 574         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 575         values.put("emp_name", "testName");
 576         values.put("emp_salary", 500);
 577         consistencyInfo.put("type", "eventual");
 578         jsonInsert.setConsistencyInfo(consistencyInfo);
 579         jsonInsert.setKeyspaceName(keyspaceName);
 580         jsonInsert.setTableName(tableName);
 581         jsonInsert.setValues(values);
 582         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 583         Response response = qData.insertIntoQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 584                 appName, authorization, jsonInsert, keyspaceName, tableName);
 585         assertEquals(200, response.getStatus());
 586     }*/
 587
 588
 589     @Test
 590     public void Test4_insertIntoQ_valuesEmpty() throws Exception {
 591         JsonInsert jsonInsert = new JsonInsert();
 592         Map<String, String> consistencyInfo = new HashMap<>();
 593         Map<String, Object> values = new HashMap<>();
 594         /*
 595         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 596         values.put("emp_name", "testName");
 597         values.put("emp_salary", 500);
 598         */
 599         consistencyInfo.put("type", "eventual");
 600         jsonInsert.setConsistencyInfo(consistencyInfo);
 601         jsonInsert.setKeyspaceName(keyspaceName);
 602         jsonInsert.setTableName(tableName);
 603         jsonInsert.setValues(values);
 604         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 605         Response response = qData.insertIntoQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 606                 appName, authorization, jsonInsert, keyspaceName, tableName);
 607         assertNotEquals(200, response.getStatus());
 608     }
 609
 610 /*    @Test
 611     public void Test4_insertIntoQ2() throws Exception {
 612         JsonInsert jsonInsert = new JsonInsert();
 613         Map<String, String> consistencyInfo = new HashMap<>();
 614         Map<String, Object> values = new HashMap<>();
 615         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 616         values.put("emp_name", "test1");
 617         values.put("emp_salary", 1500);
 618         consistencyInfo.put("type", "eventual");
 619         jsonInsert.setConsistencyInfo(consistencyInfo);
 620         jsonInsert.setKeyspaceName(keyspaceName);
 621         jsonInsert.setTableName(tableName);
 622         jsonInsert.setValues(values);
 623         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 624         Response response = qData.insertIntoQ(majorV, minorV,patchV,
 625                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 626                         jsonInsert, keyspaceName, tableName);
 627         assertEquals(200, response.getStatus());
 628     }*/
 629
 630     // Auth Error
 631     @Test
 632     public void Test4_insertIntoQ3() throws Exception {
 633         JsonInsert jsonInsert = new JsonInsert();
 634         Map<String, String> consistencyInfo = new HashMap<>();
 635         Map<String, Object> values = new HashMap<>();
 636         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 637         values.put("emp_name", "test1");
 638         values.put("emp_salary", 1500);
 639         consistencyInfo.put("type", "eventual");
 640         jsonInsert.setConsistencyInfo(consistencyInfo);
 641         jsonInsert.setKeyspaceName(keyspaceName);
 642         jsonInsert.setTableName(tableName);
 643         jsonInsert.setValues(values);
 644         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 645         Response response = qData.insertIntoQ(majorV, minorV,patchV,
 646                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
 647                         jsonInsert, keyspaceName, tableName);
 648         assertEquals(401, response.getStatus());
 649     }
 650
 651     // Table wrong
 652     @Test
 653     public void Test4_insertIntoQ4() throws Exception {
 654         JsonInsert jsonInsert = new JsonInsert();
 655         Map<String, String> consistencyInfo = new HashMap<>();
 656         Map<String, Object> values = new HashMap<>();
 657         values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 658         values.put("emp_name", "test1");
 659         values.put("emp_salary", 1500);
 660         consistencyInfo.put("type", "eventual");
 661         jsonInsert.setConsistencyInfo(consistencyInfo);
 662         jsonInsert.setKeyspaceName(keyspaceName);
 663         jsonInsert.setTableName(tableName);
 664         jsonInsert.setValues(values);
 665         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 666         Response response = qData.insertIntoQ(majorV, minorV,patchV,
 667                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 668                         jsonInsert, keyspaceName, "wrong");
 669         assertEquals(401, response.getStatus());
 670     }
 671
 672 /*    @Test
 673     public void Test5_updateQ() throws Exception {
 674         JsonUpdate jsonUpdate = new JsonUpdate();
 675         Map<String, String> consistencyInfo = new HashMap<>();
 676         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 677         Map<String, Object> values = new HashMap<>();
 678         row.add("emp_name", "testName");
 679         row.add("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 680         values.put("emp_salary", "2500");
 681         consistencyInfo.put("type", "atomic");
 682         jsonUpdate.setConsistencyInfo(consistencyInfo);
 683         jsonUpdate.setKeyspaceName(keyspaceName);
 684         jsonUpdate.setTableName(tableName);
 685         jsonUpdate.setValues(values);
 686         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 687         Mockito.when(info.getQueryParameters()).thenReturn(row);
 688         Response response = qData.updateQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 689                 authorization, jsonUpdate, keyspaceName, tableName, info);
 690         assertEquals(200, response.getStatus());
 691     }*/
 692
 693   @Test
 694   public void Test5_updateQEmptyValues() throws Exception {
 695       JsonUpdate jsonUpdate = new JsonUpdate();
 696       Map<String, String> consistencyInfo = new HashMap<>();
 697       MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 698       Map<String, Object> values = new HashMap<>();
 699       row.add("emp_name", "testName");
 700       //values.put("emp_salary", 2500);
 701       consistencyInfo.put("type", "atomic");
 702       jsonUpdate.setConsistencyInfo(consistencyInfo);
 703       jsonUpdate.setKeyspaceName(keyspaceName);
 704       jsonUpdate.setTableName(tableName);
 705       jsonUpdate.setValues(values);
 706       //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 707       //Mockito.when(info.getQueryParameters()).thenReturn(row);
 708       Response response = qData.updateQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
 709               authorization, jsonUpdate, keyspaceName, tableName, info);
 710       assertNotEquals(200, response.getStatus());
 711   }
 712
 713 /*    @Test
 714     public void Test6_filterQ() throws Exception {  //select
 715         JsonSelect jsonSelect = new JsonSelect();
 716         Map<String, String> consistencyInfo = new HashMap<>();
 717         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 718         row.add("emp_name", "testName");
 719         row.add("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
 720         consistencyInfo.put("type", "atomic");
 721         jsonSelect.setConsistencyInfo(consistencyInfo);
 722         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 723         Mockito.when(info.getQueryParameters()).thenReturn(row);
 724         Response response = qData.filter(majorV, minorV,patchV,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 725                         appName, authorization, keyspaceName, tableName, info);
 726         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 727         HashMap<String, Object> result = map.get("result");
 728         assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
 729     }*/
 730
 731 /*    @Test
 732     public void Test6_peekQ() throws Exception {  //select
 733         JsonSelect jsonSelect = new JsonSelect();
 734         Map<String, String> consistencyInfo = new HashMap<>();
 735         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 736         row.add("emp_name", "testName");
 737         consistencyInfo.put("type", "atomic");
 738         jsonSelect.setConsistencyInfo(consistencyInfo);
 739         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 740         Mockito.when(info.getQueryParameters()).thenReturn(row);
 741         Response response = qData.peek(majorV, minorV,patchV,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 742                         appName, authorization, keyspaceName, tableName, info);
 743         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 744         HashMap<String, Object> result = map.get("result");
 745         if (result.isEmpty() ) assertTrue(true);
 746         else assertFalse(false);
 747         //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
 748     }*/
 749 /*
 750     @Test
 751     public void Test6_peekQ_empty() throws Exception {  //select
 752         // row is not needed in thhis test
 753         JsonSelect jsonSelect = new JsonSelect();
 754         Map<String, String> consistencyInfo = new HashMap<>();
 755         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 756         row.add("emp_name", "testName");
 757         consistencyInfo.put("type", "atomic");
 758         jsonSelect.setConsistencyInfo(consistencyInfo);
 759         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 760         UriInfo infoe= mockUriInfo("/peek?");//empty queryParam: cause exception
 761        // infoe.setQueryParameters("");
 762         System.out.println("uriinfo="+infoe.getQueryParameters());
 763         Mockito.when(infoe.getQueryParameters()).thenReturn(row);
 764         Response response = qData.peek(majorV, minorV,patchV,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 765                         appName, authorization, keyspaceName, tableName, infoe);
 766         HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
 767         HashMap<String, Object> result = map.get("result");
 768         if (result.isEmpty() ) assertTrue(true);
 769         else assertFalse(false);
 770         //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
 771     }*/
 772
 773 /*    @Test
 774     public void Test6_deleteFromQ1() throws Exception {
 775         JsonDelete jsonDelete = new JsonDelete();
 776         Map<String, String> consistencyInfo = new HashMap<>();
 777         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 778         row.add("emp_name", "test1");
 779         consistencyInfo.put("type", "atomic");
 780         jsonDelete.setConsistencyInfo(consistencyInfo);
 781         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 782         Mockito.when(info.getQueryParameters()).thenReturn(row);
 783         Response response = qData.deleteFromQ(majorV, minorV,patchV,
 784                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 785                         jsonDelete, keyspaceName, tableName, info);
 786         assertEquals(200, response.getStatus());
 787     }*/
 788
 789     // Values
 790     @Test
 791     @Ignore
 792     public void Test6_deleteFromQ() throws Exception {
 793         JsonDelete jsonDelete = new JsonDelete();
 794         Map<String, String> consistencyInfo = new HashMap<>();
 795         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 796         consistencyInfo.put("type", "atomic");
 797         jsonDelete.setConsistencyInfo(consistencyInfo);
 798         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 799         Mockito.when(info.getQueryParameters()).thenReturn(row);
 800         Response response = qData.deleteFromQ(majorV, minorV,patchV,
 801                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 802                         jsonDelete, keyspaceName, tableName, info);
 803         assertEquals(400, response.getStatus());
 804     }
 805
 806     // delObj
 807     @Test
 808     public void Test6_deleteFromQ2() throws Exception {
 809         JsonDelete jsonDelete = new JsonDelete();
 810         Map<String, String> consistencyInfo = new HashMap<>();
 811         MultivaluedMap<String, String> row = new MultivaluedMapImpl();
 812         row.add("emp_name", "test1");
 813         consistencyInfo.put("type", "atomic");
 814         jsonDelete.setConsistencyInfo(consistencyInfo);
 815         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 816         //Mockito.when(info.getQueryParameters()).thenReturn(row);
 817         Response response = qData.deleteFromQ(majorV, minorV,patchV,
 818                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 819                         null, keyspaceName, tableName, info);
 820         assertEquals(400, response.getStatus());
 821     }
 822 /*
 823     @Test
 824     public void Test7_dropQ() throws Exception {
 825         JsonTable jsonTable = new JsonTable();
 826         Map<String, String> consistencyInfo = new HashMap<>();
 827         consistencyInfo.put("type", "atomic");
 828         jsonTable.setConsistencyInfo(consistencyInfo);
 829         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 830         Response response = qData.dropQ(majorV, minorV,patchV,
 831                         "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
 832                          keyspaceName, tableName);
 833         assertEquals(200, response.getStatus());
 834     }*/
 835
 836     private UriInfo mockUriInfo(String urix) throws URISyntaxException {
 837       String uri="http://localhost:8080/MUSIC/rest/v"+majorV+"/priorityq/keyspaces/"+keyspaceName+"/"+tableName+urix;
 838       UriInfo uriInfo = Mockito.mock(UriInfo.class);
 839       System.out.println("mock urix="+urix+" uri="+uri);
 840       Mockito.when(uriInfo.getRequestUri()).thenReturn(new URI(uri));
 841       return uriInfo;
 842       }
 843
 844
 845     //Empty Fields
 846     @Test
 847     public void Test8_createQ_fields_empty() throws Exception {
 848         String tableNameC="testcjcC";
 849         JsonTable jsonTable = new JsonTable();
 850         Map<String, String> consistencyInfo = new HashMap<>();
 851         consistencyInfo.put("type", "eventual");
 852         jsonTable.setConsistencyInfo(consistencyInfo);
 853         jsonTable.setKeyspaceName(keyspaceName);
 854         jsonTable.setPartitionKey("emp_name");
 855         jsonTable.setClusteringKey("emp_id");
 856         jsonTable.setClusteringOrder("emp_id DESC");
 857         jsonTable.setTableName(tableNameC);
 858         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 859         Response response = qData.createQ(majorV, minorV,patchV,
 860                         aid, appName, authorization,
 861                         jsonTable, keyspaceName, tableNameC);
 862         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 863         System.out.println("Entity" + response.getEntity());
 864         assertEquals(400, response.getStatus());
 865     }
 866
 867     //Partition key null
 868     @Test
 869     public void Test8_createQ_partitionKey_empty() throws Exception {
 870         String tableNameC="testcjcC";
 871         JsonTable jsonTable = new JsonTable();
 872         Map<String, String> consistencyInfo = new HashMap<>();
 873         Map<String, String> fields = new HashMap<>();
 874         fields.put("uuid", "text");
 875         fields.put("emp_name", "text");
 876         fields.put("emp_id", "text");
 877         fields.put("emp_salary", "varint");
 878         consistencyInfo.put("type", "eventual");
 879         jsonTable.setConsistencyInfo(consistencyInfo);
 880         jsonTable.setKeyspaceName(keyspaceName);
 881         jsonTable.setClusteringKey("emp_id");
 882         jsonTable.setClusteringOrder("emp_id DESC");
 883         jsonTable.setTableName(tableNameC);
 884         jsonTable.setFields(fields);
 885         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 886         Response response = qData.createQ(majorV, minorV,patchV,
 887                         aid, appName, authorization,
 888                         jsonTable, keyspaceName, tableNameC);
 889         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 890         System.out.println("Entity" + response.getEntity());
 891         assertEquals(400, response.getStatus());
 892     }
 893
 894   //Clustering key null
 895     @Test
 896     public void Test8_createQ_ClusteringKey_empty() throws Exception {
 897         String tableNameC="testcjcC";
 898         JsonTable jsonTable = new JsonTable();
 899         Map<String, String> consistencyInfo = new HashMap<>();
 900         Map<String, String> fields = new HashMap<>();
 901         fields.put("uuid", "text");
 902         fields.put("emp_name", "text");
 903         fields.put("emp_id", "text");
 904         fields.put("emp_salary", "varint");
 905         consistencyInfo.put("type", "eventual");
 906         jsonTable.setConsistencyInfo(consistencyInfo);
 907         jsonTable.setKeyspaceName(keyspaceName);
 908         jsonTable.setPartitionKey("emp_name");
 909         jsonTable.setClusteringOrder("emp_id DESC");
 910         jsonTable.setTableName(tableNameC);
 911         jsonTable.setFields(fields);
 912         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 913         Response response = qData.createQ(majorV, minorV,patchV,
 914                         aid, appName, authorization,
 915                         jsonTable, keyspaceName, tableNameC);
 916         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 917         System.out.println("Entity" + response.getEntity());
 918         assertEquals(400, response.getStatus());
 919     }
 920
 921     //Clustering Order null
 922     @Test
 923     public void Test8_createQ_ClusteringOrder_empty() throws Exception {
 924         String tableNameC="testcjcC";
 925         JsonTable jsonTable = new JsonTable();
 926         Map<String, String> consistencyInfo = new HashMap<>();
 927         Map<String, String> fields = new HashMap<>();
 928         fields.put("uuid", "text");
 929         fields.put("emp_name", "text");
 930         fields.put("emp_id", "text");
 931         fields.put("emp_salary", "varint");
 932         consistencyInfo.put("type", "eventual");
 933         jsonTable.setConsistencyInfo(consistencyInfo);
 934         jsonTable.setKeyspaceName(keyspaceName);
 935         jsonTable.setPartitionKey("emp_name");
 936         jsonTable.setClusteringKey("emp_id");
 937         jsonTable.setTableName(tableNameC);
 938         jsonTable.setFields(fields);
 939         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 940         Response response = qData.createQ(majorV, minorV,patchV,
 941                         aid, appName, authorization,
 942                         jsonTable, keyspaceName, tableNameC);
 943         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 944         System.out.println("Entity" + response.getEntity());
 945         assertEquals(400, response.getStatus());
 946     }
 947
 948   //Invalid primary key
 949     @Test
 950     public void Test8_createQ_primaryKey_invalid() throws Exception {
 951         String tableNameC="testcjcC";
 952         JsonTable jsonTable = new JsonTable();
 953         Map<String, String> consistencyInfo = new HashMap<>();
 954         Map<String, String> fields = new HashMap<>();
 955         fields.put("uuid", "text");
 956         fields.put("emp_name", "text");
 957         fields.put("emp_id", "text");
 958         fields.put("emp_salary", "varint");
 959         consistencyInfo.put("type", "eventual");
 960         jsonTable.setConsistencyInfo(consistencyInfo);
 961         jsonTable.setPrimaryKey("(emp_name");
 962         jsonTable.setKeyspaceName(keyspaceName);
 963         jsonTable.setClusteringKey("emp_id");
 964         jsonTable.setClusteringOrder("emp_id ASC");
 965         jsonTable.setTableName(tableNameC);
 966         jsonTable.setFields(fields);
 967         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 968         Response response = qData.createQ(majorV, minorV,patchV,
 969                         aid, appName, authorization,
 970                         jsonTable, keyspaceName, tableNameC);
 971         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 972         System.out.println("Entity" + response.getEntity());
 973         assertEquals(400, response.getStatus());
 974     }
 975
 976     //Primary key with no clustering key
 977     @Test
 978     public void Test8_createQ_primaryKey_with_empty_clusteringKey() throws Exception {
 979         String tableNameC="testcjcC";
 980         JsonTable jsonTable = new JsonTable();
 981         Map<String, String> consistencyInfo = new HashMap<>();
 982         Map<String, String> fields = new HashMap<>();
 983         fields.put("uuid", "text");
 984         fields.put("emp_name", "text");
 985         fields.put("emp_id", "text");
 986         fields.put("emp_salary", "varint");
 987         consistencyInfo.put("type", "eventual");
 988         jsonTable.setConsistencyInfo(consistencyInfo);
 989         jsonTable.setKeyspaceName(keyspaceName);
 990         jsonTable.setPrimaryKey("emp_name");
 991         jsonTable.setTableName(tableNameC);
 992         jsonTable.setFields(fields);
 993         jsonTable.setClusteringOrder("emp_id ASC");
 994         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 995         Response response = qData.createQ(majorV, minorV,patchV,
 996                         aid, appName, authorization,
 997                         jsonTable, keyspaceName, tableNameC);
 998         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
 999         System.out.println("Entity" + response.getEntity());
1000         assertEquals(400, response.getStatus());
1001
1002     }
1003
1004     //Primary key with no partition key
1005     @Test
1006     public void Test8_createQ_primaryKey_with_empty_partitionKey() throws Exception {
1007         String tableNameC="testcjcC";
1008         JsonTable jsonTable = new JsonTable();
1009         Map<String, String> consistencyInfo = new HashMap<>();
1010         Map<String, String> fields = new HashMap<>();
1011         fields.put("uuid", "text");
1012         fields.put("emp_name", "text");
1013         fields.put("emp_id", "text");
1014         fields.put("emp_salary", "varint");
1015         consistencyInfo.put("type", "eventual");
1016         jsonTable.setConsistencyInfo(consistencyInfo);
1017         jsonTable.setKeyspaceName(keyspaceName);
1018         jsonTable.setPrimaryKey("  ");
1019         jsonTable.setTableName(tableNameC);
1020         jsonTable.setFields(fields);
1021         jsonTable.setClusteringOrder("emp_id ASC");
1022
1023         //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1024         Response response = qData.createQ(majorV, minorV,patchV,
1025                         aid, appName, authorization,
1026                         jsonTable, keyspaceName, tableNameC);
1027         System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
1028         System.out.println("Entity" + response.getEntity());
1029         assertEquals(400, response.getStatus());
1030     }
1031
1032 }