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 java.math.BigInteger;
23 import java.util.ArrayList;
24 import java.util.HashMap;
25 import java.util.List;
27 import java.util.UUID;
28 import javax.servlet.http.HttpServletResponse;
29 import javax.ws.rs.core.MultivaluedHashMap;
30 import javax.ws.rs.core.MultivaluedMap;
31 import javax.ws.rs.core.Response;
32 import javax.ws.rs.core.UriInfo;
33 import org.junit.After;
34 import org.junit.AfterClass;
35 import org.junit.BeforeClass;
36 import org.junit.Ignore;
37 import org.junit.Test;
38 import org.junit.runner.RunWith;
39 import org.mindrot.jbcrypt.BCrypt;
40 import org.mockito.Mock;
41 import org.mockito.Mockito;
42 import org.mockito.junit.MockitoJUnitRunner;
43 import org.onap.music.datastore.MusicDataStoreHandle;
44 import org.onap.music.datastore.PreparedQueryObject;
45 import org.onap.music.datastore.jsonobjects.JsonDelete;
46 import org.onap.music.datastore.jsonobjects.JsonInsert;
47 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
48 import org.onap.music.datastore.jsonobjects.JsonSelect;
49 import org.onap.music.datastore.jsonobjects.JsonTable;
50 import org.onap.music.datastore.jsonobjects.JsonUpdate;
51 import org.onap.music.exceptions.MusicServiceException;
52 import org.onap.music.main.CachingUtil;
53 import org.onap.music.main.MusicCore;
54 import org.onap.music.main.MusicUtil;
55 import org.onap.music.main.ResultType;
56 import org.onap.music.rest.RestMusicDataAPI;
57 import com.datastax.driver.core.DataType;
58 import com.datastax.driver.core.ResultSet;
59 import com.datastax.driver.core.Row;
60 import com.sun.jersey.core.util.Base64;
61 import com.sun.jersey.core.util.MultivaluedMapImpl;
63 @RunWith(MockitoJUnitRunner.class)
64 public class TstRestMusicDataAPI {
66 RestMusicDataAPI data = new RestMusicDataAPI();
67 static PreparedQueryObject testObject;
70 HttpServletResponse http;
75 static String appName = "TestApp";
76 static String userId = "TestUser";
77 static String password = "TestPassword";
78 static String authData = userId+":"+password;
79 static String wrongAuthData = userId+":"+"pass";
80 static String authorization = new String(Base64.encode(authData.getBytes()));
81 static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
82 static boolean isAAF = false;
83 static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
84 static String keyspaceName = "testcassa";
85 static String tableName = "employees";
86 static String xLatestVersion = "X-latestVersion";
87 static String onboardUUID = null;
90 public static void init() throws Exception {
91 System.out.println("Testing RestMusicData class");
94 } catch (Exception e) {
96 throw new Exception("Unable to initialize before TestRestMusicData test class. " + e.getMessage());
101 public void afterEachTest( ) throws MusicServiceException {
102 clearAllTablesFromKeyspace();
106 public static void tearDownAfterClass() throws Exception {
107 testObject = new PreparedQueryObject();
108 testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
109 MusicCore.eventualPut(testObject);
113 public void test1_createKeyspace() throws Exception {
114 System.out.println("Testing create keyspace");
115 JsonKeySpace jsonKeyspace = new JsonKeySpace();
116 Map<String, String> consistencyInfo = new HashMap<>();
117 Map<String, Object> replicationInfo = new HashMap<>();
118 consistencyInfo.put("type", "eventual");
119 replicationInfo.put("class", "SimpleStrategy");
120 replicationInfo.put("replication_factor", 1);
121 jsonKeyspace.setConsistencyInfo(consistencyInfo);
122 jsonKeyspace.setDurabilityOfWrites("true");
123 jsonKeyspace.setKeyspaceName(keyspaceName);
124 jsonKeyspace.setReplicationInfo(replicationInfo);
125 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
126 Response response = data.createKeySpace("1", "1", "1", null,authorization, appName, jsonKeyspace, keyspaceName);
127 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
128 assertEquals(400,response.getStatus());
129 Map<String,String> respMap = (Map<String, String>) response.getEntity();
130 assertEquals(ResultType.FAILURE, respMap.get("status"));
134 public void test3_createTable() throws Exception {
135 System.out.println("Testing create table");
136 JsonTable jsonTable = new JsonTable();
137 Map<String, String> consistencyInfo = new HashMap<>();
138 Map<String, String> fields = new HashMap<>();
139 fields.put("uuid", "text");
140 fields.put("emp_name", "text");
141 fields.put("emp_salary", "varint");
142 fields.put("PRIMARY KEY", "(emp_name)");
143 consistencyInfo.put("type", "eventual");
144 jsonTable.setConsistencyInfo(consistencyInfo);
145 jsonTable.setKeyspaceName(keyspaceName);
146 jsonTable.setPrimaryKey("emp_name");
147 jsonTable.setTableName(tableName);
148 jsonTable.setFields(fields);
149 Response response = data.createTable("1", "1", "1",
150 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
151 jsonTable, keyspaceName, tableName);
152 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
153 assertEquals(200, response.getStatus());
157 public void test3_createTableNoName() throws Exception {
158 System.out.println("Testing create table without name");
159 JsonTable jsonTable = new JsonTable();
160 Map<String, String> consistencyInfo = new HashMap<>();
161 Map<String, String> fields = new HashMap<>();
162 fields.put("uuid", "text");
163 fields.put("emp_name", "text");
164 fields.put("emp_salary", "varint");
165 fields.put("PRIMARY KEY", "(emp_name)");
166 consistencyInfo.put("type", "eventual");
167 jsonTable.setConsistencyInfo(consistencyInfo);
168 jsonTable.setKeyspaceName(keyspaceName);
169 jsonTable.setPrimaryKey("emp_name");
170 jsonTable.setTableName("");
171 jsonTable.setFields(fields);
172 Response response = data.createTable("1", "1", "1",
173 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
174 jsonTable, keyspaceName, "");
175 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
176 assertEquals(400, response.getStatus());
181 public void test3_createTableClusterOrderBad() throws Exception {
182 System.out.println("Testing create table bad clustering");
183 JsonTable jsonTable = new JsonTable();
184 Map<String, String> consistencyInfo = new HashMap<>();
185 Map<String, String> fields = new HashMap<>();
186 fields.put("uuid", "text");
187 fields.put("emp_name", "text");
188 fields.put("emp_salary", "varint");
189 fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
190 consistencyInfo.put("type", "eventual");
191 jsonTable.setConsistencyInfo(consistencyInfo);
192 jsonTable.setKeyspaceName(keyspaceName);
193 jsonTable.setPrimaryKey("emp_name,emp_salary");
194 jsonTable.setClusteringOrder("ASC");
195 jsonTable.setTableName(tableName);
196 jsonTable.setFields(fields);
197 Response response = data.createTable("1", "1", "1",
198 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
199 jsonTable, keyspaceName, tableName);
200 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
201 assertEquals(400, response.getStatus());
205 public void test3_createTable_withPropertiesNotNull() throws Exception {
206 System.out.println("Testing create table with properties");
207 JsonTable jsonTable = new JsonTable();
208 Map<String, String> consistencyInfo = new HashMap<>();
209 Map<String, String> fields = new HashMap<>();
210 fields.put("uuid", "text");
211 fields.put("emp_name", "text");
212 fields.put("emp_salary", "varint");
213 fields.put("PRIMARY KEY", "(emp_name)");
214 consistencyInfo.put("type", "eventual");
215 Map<String, Object> properties = new HashMap<>();
216 properties.put("comment","Testing prperties not null");
217 jsonTable.setConsistencyInfo(consistencyInfo);
218 jsonTable.setKeyspaceName(keyspaceName);
219 jsonTable.setPrimaryKey("emp_name");
220 String tableName_prop=tableName+"_Prop";
221 jsonTable.setTableName(tableName_prop);
222 jsonTable.setFields(fields);
223 jsonTable.setProperties(properties);
225 Response response = data.createTable("1", "1", "1",
226 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
227 jsonTable, keyspaceName, tableName_prop);
228 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
229 assertEquals(200, response.getStatus());
233 public void test3_createTable_duplicateTable() throws Exception {
234 System.out.println("Testing creating duplicate tables");
235 JsonTable jsonTable = new JsonTable();
236 Map<String, String> consistencyInfo = new HashMap<>();
237 Map<String, String> fields = new HashMap<>();
238 fields.put("uuid", "text");
239 fields.put("emp_name", "text");
240 fields.put("emp_salary", "varint");
241 fields.put("PRIMARY KEY", "(emp_name)");
242 consistencyInfo.put("type", "eventual");
243 jsonTable.setConsistencyInfo(consistencyInfo);
244 jsonTable.setKeyspaceName(keyspaceName);
245 jsonTable.setPrimaryKey("emp_name");
246 String tableNameDup=tableName+"x";
247 jsonTable.setTableName(tableNameDup);
248 jsonTable.setFields(fields);
249 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
250 Response response1 = data.createTable("1", "1", "1",
251 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
252 jsonTable, keyspaceName, tableNameDup);
254 Response response2 = data.createTable("1", "1", "1",
255 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
256 jsonTable, keyspaceName, tableNameDup);
257 System.out.println("Status: " + response2.getStatus() + ". Entity " + response2.getEntity());
259 assertEquals(400, response2.getStatus());
260 Map<String,String> respMap = (Map<String, String>) response2.getEntity();
261 assertEquals(ResultType.FAILURE, respMap.get("status"));
262 assertEquals("Table " + keyspaceName + "." + tableNameDup + " already exists",
263 respMap.get("error"));
268 public void test3_createTable1() throws Exception {
269 System.out.println("Testing create table w/ improper authentication");
270 JsonTable jsonTable = new JsonTable();
271 Map<String, String> consistencyInfo = new HashMap<>();
272 Map<String, String> fields = new HashMap<>();
273 fields.put("uuid", "text");
274 fields.put("emp_name", "text");
275 fields.put("emp_salary", "varint");
276 fields.put("PRIMARY KEY", "(emp_name)");
277 consistencyInfo.put("type", "eventual");
278 jsonTable.setConsistencyInfo(consistencyInfo);
279 jsonTable.setKeyspaceName(keyspaceName);
280 jsonTable.setPrimaryKey("emp_name");
281 jsonTable.setTableName(tableName);
282 jsonTable.setFields(fields);
283 Response response = data.createTable("1", "1", "1",
284 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
285 jsonTable, keyspaceName, tableName);
286 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
287 assertEquals(401, response.getStatus());
292 public void test3_createTable3() throws Exception {
293 System.out.println("Testing create table for wrong keyspace");
294 JsonTable jsonTable = new JsonTable();
295 Map<String, String> consistencyInfo = new HashMap<>();
296 Map<String, String> fields = new HashMap<>();
297 fields.put("uuid", "text");
298 fields.put("emp_name", "text");
299 fields.put("emp_salary", "varint");
300 fields.put("PRIMARY KEY", "(emp_name)");
301 consistencyInfo.put("type", "eventual");
302 jsonTable.setConsistencyInfo(consistencyInfo);
303 jsonTable.setKeyspaceName(keyspaceName);
304 jsonTable.setPrimaryKey("emp_name");
305 jsonTable.setTableName(tableName);
306 jsonTable.setFields(fields);
307 Response response = data.createTable("1", "1", "1",
308 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
309 jsonTable, "wrong", tableName);
310 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
311 assertEquals(401, response.getStatus());
314 // Improper parenthesis in key field
316 public void test3_createTable_badParantesis() throws Exception {
317 System.out.println("Testing malformed create table request");
318 String tableNameC ="testTable0";
319 JsonTable jsonTable = new JsonTable();
320 Map<String, String> consistencyInfo = new HashMap<>();
321 Map<String, String> fields = new HashMap<>();
322 fields.put("uuid", "text");
323 fields.put("emp_name", "text");
324 fields.put("emp_salary", "varint");
325 fields.put("PRIMARY KEY", "(emp_name),emp_id)");
326 fields.put("emp_id", "varint");
327 consistencyInfo.put("type", "eventual");
328 jsonTable.setConsistencyInfo(consistencyInfo);
329 jsonTable.setKeyspaceName(keyspaceName);
330 jsonTable.setPrimaryKey("emp_name");
331 jsonTable.setTableName(tableNameC);
332 jsonTable.setClusteringOrder("emp_id Desc");
333 jsonTable.setFields(fields);
334 Response response = data.createTable("1", "1", "1",
335 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
336 jsonTable, keyspaceName, tableNameC);
337 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
339 assertEquals(400, response.getStatus());
343 // good clustering key
345 public void test3_createTable_1_clusterKey_good() throws Exception {
346 System.out.println("Testing create w/ clusterKey");
348 String tableNameC ="testTableC1";
349 JsonTable jsonTable = new JsonTable();
350 Map<String, String> consistencyInfo = new HashMap<>();
351 Map<String, String> fields = new HashMap<>();
352 fields.put("uuid", "text");
353 fields.put("emp_name", "text");
354 fields.put("emp_salary", "varint");
355 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
356 consistencyInfo.put("type", "eventual");
357 jsonTable.setConsistencyInfo(consistencyInfo);
358 jsonTable.setKeyspaceName(keyspaceName);
359 // jsonTable.setPrimaryKey("emp_name");
360 jsonTable.setTableName(tableNameC);
361 jsonTable.setClusteringOrder("emp_salary ASC");
362 jsonTable.setFields(fields);
363 Response response = data.createTable("1", "1", "1",
364 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
365 jsonTable, keyspaceName, tableNameC);
366 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
368 assertEquals(200, response.getStatus());
371 // bad partition key=clustering key
373 public void test3_createTable_2_clusterKey_bad() throws Exception {
374 System.out.println("Testing create w/ bad clusterKey");
375 String tableNameC ="testTableC2";
376 JsonTable jsonTable = new JsonTable();
377 Map<String, String> consistencyInfo = new HashMap<>();
378 Map<String, String> fields = new HashMap<>();
379 fields.put("uuid", "text");
380 fields.put("emp_name", "text");
381 fields.put("emp_salary", "varint");
382 fields.put("PRIMARY KEY", "((emp_name),emp_name)");
383 consistencyInfo.put("type", "eventual");
384 jsonTable.setConsistencyInfo(consistencyInfo);
385 jsonTable.setKeyspaceName(keyspaceName);
386 jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
387 jsonTable.setTableName(tableNameC);
388 jsonTable.setClusteringOrder("emp_salary ASC");
389 jsonTable.setFields(fields);
390 Response response = data.createTable("1", "1", "1",
391 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
392 jsonTable, keyspaceName, tableNameC);
393 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
395 assertEquals(400, response.getStatus());
398 // good composite partition key,clustering key
400 public void test3_createTable_3_pfartition_clusterKey_good() throws Exception {
401 System.out.println("Testing create w/ composite partition key, clusterKey");
403 String tableNameC ="testTableC3";
404 JsonTable jsonTable = new JsonTable();
405 Map<String, String> consistencyInfo = new HashMap<>();
406 Map<String, String> fields = new HashMap<>();
407 fields.put("uuid", "text");
408 fields.put("emp_name", "text");
409 fields.put("emp_id", "varint");
410 fields.put("emp_salary", "varint");
411 fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
412 consistencyInfo.put("type", "eventual");
413 jsonTable.setConsistencyInfo(consistencyInfo);
414 jsonTable.setKeyspaceName(keyspaceName);
415 jsonTable.setPrimaryKey("emp_name");
416 jsonTable.setTableName(tableNameC);
417 jsonTable.setClusteringOrder("emp_salary ASC");
418 jsonTable.setFields(fields);
419 Response response = data.createTable("1", "1", "1",
420 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
421 jsonTable, keyspaceName, tableNameC);
422 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
424 assertEquals(200, response.getStatus());
427 // bad - wrong cols in order by of composite partition key,clustering key
429 public void test3_createTable_5_clusteringOrder_bad() throws Exception {
430 System.out.println("Testing create table bad request with clustering & composite keys");
431 String tableNameC ="testTableC5";
432 JsonTable jsonTable = new JsonTable();
433 Map<String, String> consistencyInfo = new HashMap<>();
434 Map<String, String> fields = new HashMap<>();
435 fields.put("uuid", "text");
436 fields.put("emp_name", "text");
437 fields.put("emp_id", "varint");
438 fields.put("emp_salary", "varint");
439 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
440 consistencyInfo.put("type", "eventual");
441 jsonTable.setConsistencyInfo(consistencyInfo);
442 jsonTable.setKeyspaceName(keyspaceName);
443 jsonTable.setPrimaryKey("emp_name");
444 jsonTable.setTableName(tableNameC);
445 jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
446 jsonTable.setFields(fields);
447 Response response = data.createTable("1", "1", "1",
448 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
449 jsonTable, keyspaceName, tableNameC);
450 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
452 assertEquals(400, response.getStatus());
456 // good clustering key, need to pass queryparameter
458 public void test3_createTableIndex_1() throws Exception {
459 System.out.println("Testing index in create table");
460 String tableNameC ="testTableCinx";
461 JsonTable jsonTable = new JsonTable();
462 Map<String, String> consistencyInfo = new HashMap<>();
463 Map<String, String> fields = new HashMap<>();
464 fields.put("uuid", "text");
465 fields.put("emp_name", "text");
466 fields.put("emp_salary", "varint");
467 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
468 consistencyInfo.put("type", "eventual");
469 jsonTable.setConsistencyInfo(consistencyInfo);
470 jsonTable.setKeyspaceName(keyspaceName);
471 jsonTable.setTableName(tableNameC);
472 jsonTable.setClusteringOrder("emp_salary ASC");
473 jsonTable.setFields(fields);
474 Response response = data.createTable("1", "1", "1",
475 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
476 jsonTable, keyspaceName, tableNameC);
477 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
478 // info.setQueryParameters("index_name=inx_uuid");
479 Map<String,String> queryParametersMap =new HashMap<String, String>();
481 queryParametersMap.put("index_name","inxuuid");
482 Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedHashMap<String, String>(queryParametersMap));
483 response = data.createIndex("1", "1", "1",
484 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
485 keyspaceName, tableNameC,"uuid",info);
486 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
488 assertEquals(200, response.getStatus());
491 // create index without table name
493 public void test3_createTableIndexNoName() throws Exception {
494 System.out.println("Testing index in create table w/o tablename");
495 String tableNameC ="testTableCinx";
496 JsonTable jsonTable = new JsonTable();
497 Map<String, String> consistencyInfo = new HashMap<>();
498 Map<String, String> fields = new HashMap<>();
499 fields.put("uuid", "text");
500 fields.put("emp_name", "text");
501 fields.put("emp_salary", "varint");
502 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
503 consistencyInfo.put("type", "eventual");
504 jsonTable.setConsistencyInfo(consistencyInfo);
505 jsonTable.setKeyspaceName(keyspaceName);
506 jsonTable.setTableName(tableNameC);
507 jsonTable.setClusteringOrder("emp_salary ASC");
508 jsonTable.setFields(fields);
509 Response response = data.createTable("1", "1", "1",
510 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
511 jsonTable, keyspaceName, tableNameC);
512 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
513 // info.setQueryParameters("index_name=inx_uuid");
514 Map<String,String> queryParametersMap =new HashMap<String, String>();
516 queryParametersMap.put("index_name","inxuuid");
517 response = data.createIndex("1", "1", "1",
518 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
520 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
522 assertEquals(400, response.getStatus());
526 public void test4_insertIntoTable() throws Exception {
527 System.out.println("Testing insert into table");
529 JsonInsert jsonInsert = new JsonInsert();
530 Map<String, String> consistencyInfo = new HashMap<>();
531 Map<String, Object> values = new HashMap<>();
532 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
533 values.put("emp_name", "testname");
534 values.put("emp_salary", 500);
535 consistencyInfo.put("type", "eventual");
536 jsonInsert.setConsistencyInfo(consistencyInfo);
537 jsonInsert.setKeyspaceName(keyspaceName);
538 jsonInsert.setTableName(tableName);
539 jsonInsert.setValues(values);
540 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
541 appName, authorization, jsonInsert, keyspaceName, tableName);
542 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
544 assertEquals(200, response.getStatus());
548 public void test4_insertIntoTableCriticalNoLockID() throws Exception {
549 System.out.println("Testing atomic insert into table without lockid");
551 JsonInsert jsonInsert = new JsonInsert();
552 Map<String, String> consistencyInfo = new HashMap<>();
553 Map<String, Object> values = new HashMap<>();
554 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
555 values.put("emp_name", "testname");
556 values.put("emp_salary", 500);
557 consistencyInfo.put("type", "critical");
558 jsonInsert.setConsistencyInfo(consistencyInfo);
559 jsonInsert.setKeyspaceName(keyspaceName);
560 jsonInsert.setTableName(tableName);
561 jsonInsert.setValues(values);
562 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
563 appName, authorization, jsonInsert, keyspaceName, tableName);
564 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
566 assertEquals(400, response.getStatus());
570 public void test4_insertIntoTableNoName() throws Exception {
571 System.out.println("Testing insert into table w/o table name");
573 JsonInsert jsonInsert = new JsonInsert();
574 Map<String, String> consistencyInfo = new HashMap<>();
575 Map<String, Object> values = new HashMap<>();
576 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
577 values.put("emp_name", "testname");
578 values.put("emp_salary", 500);
579 consistencyInfo.put("type", "eventual");
580 jsonInsert.setConsistencyInfo(consistencyInfo);
581 jsonInsert.setKeyspaceName(keyspaceName);
582 jsonInsert.setTableName(tableName);
583 jsonInsert.setValues(values);
584 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
585 appName, authorization, jsonInsert, "", "");
586 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
588 assertEquals(400, response.getStatus());
592 public void test4_insertIntoTable2() throws Exception {
593 System.out.println("Testing insert into table #2");
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 Response response = data.insertIntoTable("1", "1", "1",
607 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
608 jsonInsert, keyspaceName, tableName);
609 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
611 assertEquals(200, response.getStatus());
616 public void test4_insertIntoTable3() throws Exception {
617 System.out.println("Testing insert into table with bad credentials");
619 JsonInsert jsonInsert = new JsonInsert();
620 Map<String, String> consistencyInfo = new HashMap<>();
621 Map<String, Object> values = new HashMap<>();
622 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
623 values.put("emp_name", "test1");
624 values.put("emp_salary", 1500);
625 consistencyInfo.put("type", "eventual");
626 jsonInsert.setConsistencyInfo(consistencyInfo);
627 jsonInsert.setKeyspaceName(keyspaceName);
628 jsonInsert.setTableName(tableName);
629 jsonInsert.setValues(values);
630 Response response = data.insertIntoTable("1", "1", "1",
631 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
632 jsonInsert, keyspaceName, tableName);
633 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
635 assertEquals(401, response.getStatus());
640 public void test4_insertIntoTable4() throws Exception {
641 System.out.println("Testing insert into wrong table");
643 JsonInsert jsonInsert = new JsonInsert();
644 Map<String, String> consistencyInfo = new HashMap<>();
645 Map<String, Object> values = new HashMap<>();
646 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
647 values.put("emp_name", "test1");
648 values.put("emp_salary", 1500);
649 consistencyInfo.put("type", "eventual");
650 jsonInsert.setConsistencyInfo(consistencyInfo);
651 jsonInsert.setKeyspaceName(keyspaceName);
652 jsonInsert.setTableName(tableName);
653 jsonInsert.setValues(values);
654 Response response = data.insertIntoTable("1", "1", "1",
655 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
656 jsonInsert, keyspaceName, "wrong");
657 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
659 assertEquals(400, response.getStatus());
664 public void test5_updateTable() throws Exception {
665 System.out.println("Testing update table");
668 JsonUpdate jsonUpdate = new JsonUpdate();
669 Map<String, String> consistencyInfo = new HashMap<>();
670 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
671 Map<String, Object> values = new HashMap<>();
672 row.add("emp_name", "testname");
673 values.put("emp_salary", 2500);
674 consistencyInfo.put("type", "atomic");
675 jsonUpdate.setConsistencyInfo(consistencyInfo);
676 jsonUpdate.setKeyspaceName(keyspaceName);
677 jsonUpdate.setTableName(tableName);
678 jsonUpdate.setValues(values);
679 Mockito.when(info.getQueryParameters()).thenReturn(row);
680 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
681 authorization, jsonUpdate, keyspaceName, tableName, info);
683 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
685 assertEquals(200, response.getStatus());
689 public void test5_updateTableNoName() throws Exception {
690 System.out.println("Testing update table without tablename");
693 JsonUpdate jsonUpdate = new JsonUpdate();
694 Map<String, String> consistencyInfo = new HashMap<>();
695 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
696 Map<String, Object> values = new HashMap<>();
697 row.add("emp_name", "testname");
698 values.put("emp_salary", 2500);
699 consistencyInfo.put("type", "atomic");
700 jsonUpdate.setConsistencyInfo(consistencyInfo);
701 jsonUpdate.setKeyspaceName(keyspaceName);
702 jsonUpdate.setTableName(tableName);
703 jsonUpdate.setValues(values);
704 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
705 authorization, jsonUpdate, "", "", info);
707 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
709 assertEquals(400, response.getStatus());
712 // need mock code to create error for MusicCore methods
714 public void test5_updateTableAuthE() throws Exception {
715 System.out.println("Testing update table #2");
717 //MockitoAnnotations.initMocks(this);
718 JsonUpdate jsonUpdate = new JsonUpdate();
719 Map<String, String> consistencyInfo = new HashMap<>();
720 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
721 Map<String, Object> values = new HashMap<>();
722 row.add("emp_name", "testname");
723 values.put("emp_salary", 2500);
724 consistencyInfo.put("type", "atomic");
725 jsonUpdate.setConsistencyInfo(consistencyInfo);
726 jsonUpdate.setKeyspaceName(keyspaceName);
727 jsonUpdate.setTableName(tableName);
728 jsonUpdate.setValues(values);
729 //add ttl & timestamp
730 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
731 Mockito.when(info.getQueryParameters()).thenReturn(row);
732 //Map<String, Object> m1= new HashMap<>() ;
733 //Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
734 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
735 authorization, jsonUpdate, keyspaceName, tableName, info);
736 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
738 assertEquals(200, response.getStatus());
743 public void test5_updateTableAuthException1() throws Exception {
744 System.out.println("Testing update table authentication error");
746 JsonUpdate jsonUpdate = new JsonUpdate();
747 Map<String, String> consistencyInfo = new HashMap<>();
748 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
749 Map<String, Object> values = new HashMap<>();
750 row.add("emp_name", "testname");
751 values.put("emp_salary", 2500);
752 consistencyInfo.put("type", "atomic");
753 jsonUpdate.setConsistencyInfo(consistencyInfo);
754 jsonUpdate.setKeyspaceName(keyspaceName);
755 jsonUpdate.setTableName(tableName);
756 jsonUpdate.setValues(values);
758 Mockito.when(info.getQueryParameters()).thenReturn(row);
759 String authDatax = ":";
760 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
761 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
762 authorizationx, jsonUpdate, keyspaceName, tableName, info);
763 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
765 assertEquals(401, response.getStatus());
770 public void test5_updateTableAuthEmpty() throws Exception {
771 System.out.println("Testing update table without authentication");
774 JsonUpdate jsonUpdate = new JsonUpdate();
775 Map<String, String> consistencyInfo = new HashMap<>();
776 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
777 Map<String, Object> values = new HashMap<>();
778 row.add("emp_name", "testname");
779 values.put("emp_salary", 2500);
780 consistencyInfo.put("type", "atomic");
781 jsonUpdate.setConsistencyInfo(consistencyInfo);
782 jsonUpdate.setKeyspaceName(keyspaceName);
783 jsonUpdate.setTableName(tableName);
784 jsonUpdate.setValues(values);
786 Mockito.when(info.getQueryParameters()).thenReturn(row);
787 String authDatax =":"+password;
788 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
789 String appNamex="xx";
790 Response response = data.updateTable("1", "1", "1", "", appNamex,
791 authorizationx, jsonUpdate, keyspaceName, tableName, info);
792 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
794 assertEquals(401, response.getStatus());
799 public void test6_select() throws Exception {
800 System.out.println("Testing select");
801 createAndInsertIntoTable();
802 JsonSelect jsonSelect = new JsonSelect();
803 Map<String, String> consistencyInfo = new HashMap<>();
804 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
805 row.add("emp_name", "testname");
806 consistencyInfo.put("type", "atomic");
807 jsonSelect.setConsistencyInfo(consistencyInfo);
808 Mockito.when(info.getQueryParameters()).thenReturn(row);
809 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
810 appName, authorization, keyspaceName, tableName, info);
811 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
812 HashMap<String, Object> result = map.get("result");
813 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
815 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
816 assertEquals("testname", row0.get("emp_name"));
817 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
821 public void test6_selectCritical() throws Exception {
822 System.out.println("Testing select critical");
823 createAndInsertIntoTable();
824 JsonInsert jsonInsert = new JsonInsert();
825 Map<String, String> consistencyInfo = new HashMap<>();
826 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
827 row.add("emp_name", "testname");
828 consistencyInfo.put("type", "atomic");
829 jsonInsert.setConsistencyInfo(consistencyInfo);
830 Mockito.when(info.getQueryParameters()).thenReturn(row);
831 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
832 appName, authorization, jsonInsert, keyspaceName, tableName,info);
833 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
834 HashMap<String, Object> result = map.get("result");
835 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
837 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
838 assertEquals("testname", row0.get("emp_name"));
839 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
843 public void test6_deleteFromTable() throws Exception {
844 System.out.println("Testing delete from table");
845 createAndInsertIntoTable();
846 JsonDelete jsonDelete = new JsonDelete();
847 Map<String, String> consistencyInfo = new HashMap<>();
848 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
849 row.add("emp_name", "test1");
850 consistencyInfo.put("type", "atomic");
851 jsonDelete.setConsistencyInfo(consistencyInfo);
852 Mockito.when(info.getQueryParameters()).thenReturn(row);
853 Response response = data.deleteFromTable("1", "1", "1",
854 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
855 jsonDelete, keyspaceName, tableName, info);
856 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
858 assertEquals(200, response.getStatus());
864 public void test6_deleteFromTable1() throws Exception {
865 System.out.println("Testing delete from table missing delete object");
866 createAndInsertIntoTable();
868 JsonDelete jsonDelete = new JsonDelete();
869 Map<String, String> consistencyInfo = new HashMap<>();
870 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
871 consistencyInfo.put("type", "atomic");
872 jsonDelete.setConsistencyInfo(consistencyInfo);
873 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
874 Mockito.when(info.getQueryParameters()).thenReturn(row);
875 Response response = data.deleteFromTable("1", "1", "1",
876 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
877 jsonDelete, keyspaceName, tableName, info);
878 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
880 assertEquals(400, response.getStatus());
885 public void test6_deleteFromTable2() throws Exception {
886 System.out.println("Testing delete from table missing delete object");
887 createAndInsertIntoTable();
888 JsonDelete jsonDelete = new JsonDelete();
889 Map<String, String> consistencyInfo = new HashMap<>();
890 consistencyInfo.put("type", "atomic");
891 jsonDelete.setConsistencyInfo(consistencyInfo);
892 Response response = data.deleteFromTable("1", "1", "1",
893 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
894 null, keyspaceName, tableName, info);
895 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
897 assertEquals(400, response.getStatus());
901 public void test7_dropTable() throws Exception {
902 System.out.println("Testing drop table");
904 JsonTable jsonTable = new JsonTable();
905 Map<String, String> consistencyInfo = new HashMap<>();
906 consistencyInfo.put("type", "atomic");
907 jsonTable.setConsistencyInfo(consistencyInfo);
908 Response response = data.dropTable("1", "1", "1",
909 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
910 keyspaceName, tableName);
911 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
913 assertEquals(200, response.getStatus());
918 public void test8_deleteKeyspace() throws Exception {
919 System.out.println("Testing drop keyspace");
921 JsonKeySpace jsonKeyspace = new JsonKeySpace();
922 Map<String, String> consistencyInfo = new HashMap<>();
923 Map<String, Object> replicationInfo = new HashMap<>();
924 consistencyInfo.put("type", "eventual");
925 replicationInfo.put("class", "SimpleStrategy");
926 replicationInfo.put("replication_factor", 1);
927 jsonKeyspace.setConsistencyInfo(consistencyInfo);
928 jsonKeyspace.setDurabilityOfWrites("true");
929 jsonKeyspace.setKeyspaceName("TestApp1");
930 jsonKeyspace.setReplicationInfo(replicationInfo);
931 Response response = data.dropKeySpace("1", "1", "1",
932 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,appName, keyspaceName);
933 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
935 assertEquals(400, response.getStatus());
938 private static void createAdminTable() throws Exception {
939 testObject = new PreparedQueryObject();
940 testObject.appendQueryString(CassandraCQL.createAdminKeyspace);
941 MusicCore.eventualPut(testObject);
942 testObject = new PreparedQueryObject();
943 testObject.appendQueryString(CassandraCQL.createAdminTable);
944 MusicCore.eventualPut(testObject);
946 testObject = new PreparedQueryObject();
947 testObject.appendQueryString(
948 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
949 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
950 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
951 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
952 MusicUtil.DEFAULTKEYSPACENAME));
953 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
954 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
955 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
956 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
957 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
958 MusicCore.eventualPut(testObject);
960 testObject = new PreparedQueryObject();
961 testObject.appendQueryString(
962 "select uuid from admin.keyspace_master where application_name = ? allow filtering");
963 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
964 ResultSet rs = MusicCore.get(testObject);
965 List<Row> rows = rs.all();
966 if (rows.size() > 0) {
967 System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
972 private static void createKeyspace() throws Exception {
973 //shouldn't really be doing this here, but create keyspace is currently turned off
974 PreparedQueryObject query = new PreparedQueryObject();
975 query.appendQueryString(CassandraCQL.createKeySpace);
976 MusicCore.eventualPut(query);
978 boolean isAAF = false;
979 String hashedpwd = BCrypt.hashpw(password, BCrypt.gensalt());
980 query = new PreparedQueryObject();
981 query.appendQueryString(
982 "INSERT into admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
983 + "password, username, is_aaf) values (?,?,?,?,?,?,?)");
984 query.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
985 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), keyspaceName));
986 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
987 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
988 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), hashedpwd));
989 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
990 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
991 CachingUtil.updateMusicCache(keyspaceName, appName);
992 CachingUtil.updateMusicValidateCache(appName, userId, hashedpwd);
993 MusicCore.eventualPut(query);
996 private void clearAllTablesFromKeyspace() throws MusicServiceException {
997 ArrayList<String> tableNames = new ArrayList<>();
998 PreparedQueryObject query = new PreparedQueryObject();
999 query.appendQueryString("SELECT table_name FROM system_schema.tables WHERE keyspace_name = '"+keyspaceName+"';");
1000 ResultSet rs = MusicCore.get(query);
1002 tableNames.add(row.getString("table_name"));
1004 for (String table: tableNames) {
1005 query = new PreparedQueryObject();
1006 query.appendQueryString("DROP TABLE " + keyspaceName + "." + table);
1007 MusicCore.eventualPut(query);
1012 * Create a table {@link tableName} in {@link keyspaceName}
1015 private void createTable() throws Exception {
1016 JsonTable jsonTable = new JsonTable();
1017 Map<String, String> consistencyInfo = new HashMap<>();
1018 Map<String, String> fields = new HashMap<>();
1019 fields.put("uuid", "text");
1020 fields.put("emp_name", "text");
1021 fields.put("emp_salary", "varint");
1022 fields.put("PRIMARY KEY", "(emp_name)");
1023 consistencyInfo.put("type", "eventual");
1024 jsonTable.setConsistencyInfo(consistencyInfo);
1025 jsonTable.setKeyspaceName(keyspaceName);
1026 jsonTable.setPrimaryKey("emp_name");
1027 jsonTable.setTableName(tableName);
1028 jsonTable.setFields(fields);
1029 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1030 Response response = data.createTable("1", "1", "1",
1031 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
1032 jsonTable, keyspaceName, tableName);
1036 * Create table {@link createTable} and insert into said table
1039 private void createAndInsertIntoTable() throws Exception {
1042 JsonInsert jsonInsert = new JsonInsert();
1043 Map<String, String> consistencyInfo = new HashMap<>();
1044 Map<String, Object> values = new HashMap<>();
1045 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1046 values.put("emp_name", "testname");
1047 values.put("emp_salary", 500);
1048 consistencyInfo.put("type", "eventual");
1049 jsonInsert.setConsistencyInfo(consistencyInfo);
1050 jsonInsert.setKeyspaceName(keyspaceName);
1051 jsonInsert.setTableName(tableName);
1052 jsonInsert.setValues(values);
1053 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1054 appName, authorization, jsonInsert, keyspaceName, tableName);