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

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