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