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