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