2 * ============LICENSE_START==========================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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.
19 * ============LICENSE_END=============================================
20 * ====================================================================
23 package org.onap.music.unittests;
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;
32 import java.net.URISyntaxException;
33 import java.util.HashMap;
34 import java.util.List;
35 //cjc import java.util.List;
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;
84 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
85 @RunWith(MockitoJUnitRunner.class)
86 public class TestRestMusicQAPI {
89 //RestMusicAdminAPI admin = new RestMusicAdminAPI();
90 RestMusicLocksAPI lock = new RestMusicLocksAPI();
91 RestMusicQAPI qData = new RestMusicQAPI();
92 static PreparedQueryObject testObject;
95 static HttpServletResponse http;
100 static String appName = "TestApp";
101 static String userId = "TestUser";
102 static String password = "TestPassword";
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";
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()));
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;
131 public static void init() throws Exception {
133 ReflectionTestUtils.setField(MusicDataStoreHandle.class, "mDstoreHandle",
134 CassandraCQL.connectToEmbeddedCassandra());
135 MusicCore.mLockHandle = new CassaLockStore(MusicDataStoreHandle.getDSHandle());
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 ");
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);
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);
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);
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"));
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);
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");
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());
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<>();
261 fields.put("uuid", "text");
262 fields.put("emp_name", "text");
263 fields.put("emp_salary", "varint");
264 fields.put("PRIMARY KEY", "(emp_name)");
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
516 assertFalse("Duplicate table not created for "+tableNameDup, 200==response0.getStatus());
517 //assertEquals(400, response0.getStatus());
518 //assertNotEquals(200,response0.getStatus());
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());
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());
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<>();
578 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
579 values.put("emp_name", "testName");
580 values.put("emp_salary", 500);
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
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());
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));
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());
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());
837 //Clustering key null
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());
864 //Clustering Order null
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());
891 //Invalid primary key
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());
919 //Primary key with no clustering key
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());
947 //Primary key with no partition key
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");
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());