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