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());
158 public void test3_createTableClusterOrderBad() throws Exception {
159 System.out.println("Testing create table bad clustering");
160 JsonTable jsonTable = new JsonTable();
161 Map<String, String> consistencyInfo = new HashMap<>();
162 Map<String, String> fields = new HashMap<>();
163 fields.put("uuid", "text");
164 fields.put("emp_name", "text");
165 fields.put("emp_salary", "varint");
166 fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
167 consistencyInfo.put("type", "eventual");
168 jsonTable.setConsistencyInfo(consistencyInfo);
169 jsonTable.setKeyspaceName(keyspaceName);
170 jsonTable.setPrimaryKey("emp_name,emp_salary");
171 jsonTable.setClusteringOrder("ASC");
172 jsonTable.setTableName(tableName);
173 jsonTable.setFields(fields);
174 Response response = data.createTable("1", "1", "1",
175 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
176 jsonTable, keyspaceName, tableName);
177 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
178 assertEquals(400, response.getStatus());
182 public void test3_createTable_withPropertiesNotNull() throws Exception {
183 System.out.println("Testing create table with properties");
184 JsonTable jsonTable = new JsonTable();
185 Map<String, String> consistencyInfo = new HashMap<>();
186 Map<String, String> fields = new HashMap<>();
187 fields.put("uuid", "text");
188 fields.put("emp_name", "text");
189 fields.put("emp_salary", "varint");
190 fields.put("PRIMARY KEY", "(emp_name)");
191 consistencyInfo.put("type", "eventual");
192 Map<String, Object> properties = new HashMap<>();
193 properties.put("comment","Testing prperties not null");
194 jsonTable.setConsistencyInfo(consistencyInfo);
195 jsonTable.setKeyspaceName(keyspaceName);
196 jsonTable.setPrimaryKey("emp_name");
197 String tableName_prop=tableName+"_Prop";
198 jsonTable.setTableName(tableName_prop);
199 jsonTable.setFields(fields);
200 jsonTable.setProperties(properties);
202 Response response = data.createTable("1", "1", "1",
203 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
204 jsonTable, keyspaceName, tableName_prop);
205 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
206 assertEquals(200, response.getStatus());
210 public void test3_createTable_duplicateTable() throws Exception {
211 System.out.println("Testing creating duplicate tables");
212 JsonTable jsonTable = new JsonTable();
213 Map<String, String> consistencyInfo = new HashMap<>();
214 Map<String, String> fields = new HashMap<>();
215 fields.put("uuid", "text");
216 fields.put("emp_name", "text");
217 fields.put("emp_salary", "varint");
218 fields.put("PRIMARY KEY", "(emp_name)");
219 consistencyInfo.put("type", "eventual");
220 jsonTable.setConsistencyInfo(consistencyInfo);
221 jsonTable.setKeyspaceName(keyspaceName);
222 jsonTable.setPrimaryKey("emp_name");
223 String tableNameDup=tableName+"x";
224 jsonTable.setTableName(tableNameDup);
225 jsonTable.setFields(fields);
226 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
227 Response response1 = data.createTable("1", "1", "1",
228 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
229 jsonTable, keyspaceName, tableNameDup);
231 Response response2 = data.createTable("1", "1", "1",
232 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
233 jsonTable, keyspaceName, tableNameDup);
234 System.out.println("Status: " + response2.getStatus() + ". Entity " + response2.getEntity());
236 assertEquals(400, response2.getStatus());
237 Map<String,String> respMap = (Map<String, String>) response2.getEntity();
238 assertEquals(ResultType.FAILURE, respMap.get("status"));
239 assertEquals("Table " + keyspaceName + "." + tableNameDup + " already exists",
240 respMap.get("error"));
245 public void test3_createTable1() throws Exception {
246 System.out.println("Testing create table w/ improper authentication");
247 JsonTable jsonTable = new JsonTable();
248 Map<String, String> consistencyInfo = new HashMap<>();
249 Map<String, String> fields = new HashMap<>();
250 fields.put("uuid", "text");
251 fields.put("emp_name", "text");
252 fields.put("emp_salary", "varint");
253 fields.put("PRIMARY KEY", "(emp_name)");
254 consistencyInfo.put("type", "eventual");
255 jsonTable.setConsistencyInfo(consistencyInfo);
256 jsonTable.setKeyspaceName(keyspaceName);
257 jsonTable.setPrimaryKey("emp_name");
258 jsonTable.setTableName(tableName);
259 jsonTable.setFields(fields);
260 Response response = data.createTable("1", "1", "1",
261 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
262 jsonTable, keyspaceName, tableName);
263 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
264 assertEquals(401, response.getStatus());
269 public void test3_createTable3() throws Exception {
270 System.out.println("Testing create table for wrong keyspace");
271 JsonTable jsonTable = new JsonTable();
272 Map<String, String> consistencyInfo = new HashMap<>();
273 Map<String, String> fields = new HashMap<>();
274 fields.put("uuid", "text");
275 fields.put("emp_name", "text");
276 fields.put("emp_salary", "varint");
277 fields.put("PRIMARY KEY", "(emp_name)");
278 consistencyInfo.put("type", "eventual");
279 jsonTable.setConsistencyInfo(consistencyInfo);
280 jsonTable.setKeyspaceName(keyspaceName);
281 jsonTable.setPrimaryKey("emp_name");
282 jsonTable.setTableName(tableName);
283 jsonTable.setFields(fields);
284 Response response = data.createTable("1", "1", "1",
285 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
286 jsonTable, "wrong", tableName);
287 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
288 assertEquals(401, response.getStatus());
291 // Improper parenthesis in key field
293 public void test3_createTable_badParantesis() throws Exception {
294 System.out.println("Testing malformed create table request");
295 String tableNameC ="testTable0";
296 JsonTable jsonTable = new JsonTable();
297 Map<String, String> consistencyInfo = new HashMap<>();
298 Map<String, String> fields = new HashMap<>();
299 fields.put("uuid", "text");
300 fields.put("emp_name", "text");
301 fields.put("emp_salary", "varint");
302 fields.put("PRIMARY KEY", "(emp_name),emp_id)");
303 fields.put("emp_id", "varint");
304 consistencyInfo.put("type", "eventual");
305 jsonTable.setConsistencyInfo(consistencyInfo);
306 jsonTable.setKeyspaceName(keyspaceName);
307 jsonTable.setPrimaryKey("emp_name");
308 jsonTable.setTableName(tableNameC);
309 jsonTable.setClusteringOrder("emp_id Desc");
310 jsonTable.setFields(fields);
311 Response response = data.createTable("1", "1", "1",
312 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
313 jsonTable, keyspaceName, tableNameC);
314 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
316 assertEquals(400, response.getStatus());
320 // good clustering key
322 public void test3_createTable_1_clusterKey_good() throws Exception {
323 System.out.println("Testing create w/ clusterKey");
325 String tableNameC ="testTableC1";
326 JsonTable jsonTable = new JsonTable();
327 Map<String, String> consistencyInfo = new HashMap<>();
328 Map<String, String> fields = new HashMap<>();
329 fields.put("uuid", "text");
330 fields.put("emp_name", "text");
331 fields.put("emp_salary", "varint");
332 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
333 consistencyInfo.put("type", "eventual");
334 jsonTable.setConsistencyInfo(consistencyInfo);
335 jsonTable.setKeyspaceName(keyspaceName);
336 // jsonTable.setPrimaryKey("emp_name");
337 jsonTable.setTableName(tableNameC);
338 jsonTable.setClusteringOrder("emp_salary ASC");
339 jsonTable.setFields(fields);
340 Response response = data.createTable("1", "1", "1",
341 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
342 jsonTable, keyspaceName, tableNameC);
343 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
345 assertEquals(200, response.getStatus());
348 // bad partition key=clustering key
350 public void test3_createTable_2_clusterKey_bad() throws Exception {
351 System.out.println("Testing create w/ bad clusterKey");
352 String tableNameC ="testTableC2";
353 JsonTable jsonTable = new JsonTable();
354 Map<String, String> consistencyInfo = new HashMap<>();
355 Map<String, String> fields = new HashMap<>();
356 fields.put("uuid", "text");
357 fields.put("emp_name", "text");
358 fields.put("emp_salary", "varint");
359 fields.put("PRIMARY KEY", "((emp_name),emp_name)");
360 consistencyInfo.put("type", "eventual");
361 jsonTable.setConsistencyInfo(consistencyInfo);
362 jsonTable.setKeyspaceName(keyspaceName);
363 jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
364 jsonTable.setTableName(tableNameC);
365 jsonTable.setClusteringOrder("emp_salary ASC");
366 jsonTable.setFields(fields);
367 Response response = data.createTable("1", "1", "1",
368 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
369 jsonTable, keyspaceName, tableNameC);
370 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
372 assertEquals(400, response.getStatus());
375 // good composite partition key,clustering key
377 public void test3_createTable_3_pfartition_clusterKey_good() throws Exception {
378 System.out.println("Testing create w/ composite partition key, clusterKey");
380 String tableNameC ="testTableC3";
381 JsonTable jsonTable = new JsonTable();
382 Map<String, String> consistencyInfo = new HashMap<>();
383 Map<String, String> fields = new HashMap<>();
384 fields.put("uuid", "text");
385 fields.put("emp_name", "text");
386 fields.put("emp_id", "varint");
387 fields.put("emp_salary", "varint");
388 fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
389 consistencyInfo.put("type", "eventual");
390 jsonTable.setConsistencyInfo(consistencyInfo);
391 jsonTable.setKeyspaceName(keyspaceName);
392 jsonTable.setPrimaryKey("emp_name");
393 jsonTable.setTableName(tableNameC);
394 jsonTable.setClusteringOrder("emp_salary ASC");
395 jsonTable.setFields(fields);
396 Response response = data.createTable("1", "1", "1",
397 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
398 jsonTable, keyspaceName, tableNameC);
399 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
401 assertEquals(200, response.getStatus());
404 // bad - wrong cols in order by of composite partition key,clustering key
406 public void test3_createTable_5_clusteringOrder_bad() throws Exception {
407 System.out.println("Testing create table bad request with clustering & composite keys");
408 String tableNameC ="testTableC5";
409 JsonTable jsonTable = new JsonTable();
410 Map<String, String> consistencyInfo = new HashMap<>();
411 Map<String, String> fields = new HashMap<>();
412 fields.put("uuid", "text");
413 fields.put("emp_name", "text");
414 fields.put("emp_id", "varint");
415 fields.put("emp_salary", "varint");
416 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
417 consistencyInfo.put("type", "eventual");
418 jsonTable.setConsistencyInfo(consistencyInfo);
419 jsonTable.setKeyspaceName(keyspaceName);
420 jsonTable.setPrimaryKey("emp_name");
421 jsonTable.setTableName(tableNameC);
422 jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
423 jsonTable.setFields(fields);
424 Response response = data.createTable("1", "1", "1",
425 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
426 jsonTable, keyspaceName, tableNameC);
427 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
429 assertEquals(400, response.getStatus());
433 // good clustering key, need to pass queryparameter
435 public void test3_createTableIndex_1() throws Exception {
436 System.out.println("Testing index in create table");
437 String tableNameC ="testTableCinx";
438 JsonTable jsonTable = new JsonTable();
439 Map<String, String> consistencyInfo = new HashMap<>();
440 Map<String, String> fields = new HashMap<>();
441 fields.put("uuid", "text");
442 fields.put("emp_name", "text");
443 fields.put("emp_salary", "varint");
444 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
445 consistencyInfo.put("type", "eventual");
446 jsonTable.setConsistencyInfo(consistencyInfo);
447 jsonTable.setKeyspaceName(keyspaceName);
448 jsonTable.setTableName(tableNameC);
449 jsonTable.setClusteringOrder("emp_salary ASC");
450 jsonTable.setFields(fields);
451 Response response = data.createTable("1", "1", "1",
452 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
453 jsonTable, keyspaceName, tableNameC);
454 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
455 // info.setQueryParameters("index_name=inx_uuid");
456 Map<String,String> queryParametersMap =new HashMap<String, String>();
458 queryParametersMap.put("index_name","inxuuid");
459 Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedHashMap<String, String>(queryParametersMap));
460 response = data.createIndex("1", "1", "1",
461 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
462 keyspaceName, tableNameC,"uuid",info);
463 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
465 assertEquals(200, response.getStatus());
469 public void test4_insertIntoTable() throws Exception {
470 System.out.println("Testing insert into table");
472 JsonInsert jsonInsert = new JsonInsert();
473 Map<String, String> consistencyInfo = new HashMap<>();
474 Map<String, Object> values = new HashMap<>();
475 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
476 values.put("emp_name", "testname");
477 values.put("emp_salary", 500);
478 consistencyInfo.put("type", "eventual");
479 jsonInsert.setConsistencyInfo(consistencyInfo);
480 jsonInsert.setKeyspaceName(keyspaceName);
481 jsonInsert.setTableName(tableName);
482 jsonInsert.setValues(values);
483 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
484 appName, authorization, jsonInsert, keyspaceName, tableName);
485 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
487 assertEquals(200, response.getStatus());
491 public void test4_insertIntoTable2() throws Exception {
492 System.out.println("Testing insert into table #2");
494 JsonInsert jsonInsert = new JsonInsert();
495 Map<String, String> consistencyInfo = new HashMap<>();
496 Map<String, Object> values = new HashMap<>();
497 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
498 values.put("emp_name", "test1");
499 values.put("emp_salary", 1500);
500 consistencyInfo.put("type", "eventual");
501 jsonInsert.setConsistencyInfo(consistencyInfo);
502 jsonInsert.setKeyspaceName(keyspaceName);
503 jsonInsert.setTableName(tableName);
504 jsonInsert.setValues(values);
505 Response response = data.insertIntoTable("1", "1", "1",
506 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
507 jsonInsert, keyspaceName, tableName);
508 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
510 assertEquals(200, response.getStatus());
515 public void test4_insertIntoTable3() throws Exception {
516 System.out.println("Testing insert into table with bad credentials");
518 JsonInsert jsonInsert = new JsonInsert();
519 Map<String, String> consistencyInfo = new HashMap<>();
520 Map<String, Object> values = new HashMap<>();
521 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
522 values.put("emp_name", "test1");
523 values.put("emp_salary", 1500);
524 consistencyInfo.put("type", "eventual");
525 jsonInsert.setConsistencyInfo(consistencyInfo);
526 jsonInsert.setKeyspaceName(keyspaceName);
527 jsonInsert.setTableName(tableName);
528 jsonInsert.setValues(values);
529 Response response = data.insertIntoTable("1", "1", "1",
530 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
531 jsonInsert, keyspaceName, tableName);
532 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
534 assertEquals(401, response.getStatus());
539 public void test4_insertIntoTable4() throws Exception {
540 System.out.println("Testing insert into wrong table");
542 JsonInsert jsonInsert = new JsonInsert();
543 Map<String, String> consistencyInfo = new HashMap<>();
544 Map<String, Object> values = new HashMap<>();
545 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
546 values.put("emp_name", "test1");
547 values.put("emp_salary", 1500);
548 consistencyInfo.put("type", "eventual");
549 jsonInsert.setConsistencyInfo(consistencyInfo);
550 jsonInsert.setKeyspaceName(keyspaceName);
551 jsonInsert.setTableName(tableName);
552 jsonInsert.setValues(values);
553 Response response = data.insertIntoTable("1", "1", "1",
554 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
555 jsonInsert, keyspaceName, "wrong");
556 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
558 assertEquals(400, response.getStatus());
563 public void test5_updateTable() throws Exception {
564 System.out.println("Testing update table");
567 JsonUpdate jsonUpdate = new JsonUpdate();
568 Map<String, String> consistencyInfo = new HashMap<>();
569 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
570 Map<String, Object> values = new HashMap<>();
571 row.add("emp_name", "testname");
572 values.put("emp_salary", 2500);
573 consistencyInfo.put("type", "atomic");
574 jsonUpdate.setConsistencyInfo(consistencyInfo);
575 jsonUpdate.setKeyspaceName(keyspaceName);
576 jsonUpdate.setTableName(tableName);
577 jsonUpdate.setValues(values);
578 Mockito.when(info.getQueryParameters()).thenReturn(row);
579 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
580 authorization, jsonUpdate, keyspaceName, tableName, info);
582 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
584 assertEquals(200, response.getStatus());
587 // need mock code to create error for MusicCore methods
589 public void test5_updateTableAuthE() throws Exception {
590 System.out.println("Testing update table #2");
592 //MockitoAnnotations.initMocks(this);
593 JsonUpdate jsonUpdate = new JsonUpdate();
594 Map<String, String> consistencyInfo = new HashMap<>();
595 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
596 Map<String, Object> values = new HashMap<>();
597 row.add("emp_name", "testname");
598 values.put("emp_salary", 2500);
599 consistencyInfo.put("type", "atomic");
600 jsonUpdate.setConsistencyInfo(consistencyInfo);
601 jsonUpdate.setKeyspaceName(keyspaceName);
602 jsonUpdate.setTableName(tableName);
603 jsonUpdate.setValues(values);
604 //add ttl & timestamp
605 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
606 Mockito.when(info.getQueryParameters()).thenReturn(row);
607 //Map<String, Object> m1= new HashMap<>() ;
608 //Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
609 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
610 authorization, jsonUpdate, keyspaceName, tableName, info);
611 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
613 assertEquals(200, response.getStatus());
618 public void test5_updateTableAuthException1() throws Exception {
619 System.out.println("Testing update table authentication error");
621 JsonUpdate jsonUpdate = new JsonUpdate();
622 Map<String, String> consistencyInfo = new HashMap<>();
623 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
624 Map<String, Object> values = new HashMap<>();
625 row.add("emp_name", "testname");
626 values.put("emp_salary", 2500);
627 consistencyInfo.put("type", "atomic");
628 jsonUpdate.setConsistencyInfo(consistencyInfo);
629 jsonUpdate.setKeyspaceName(keyspaceName);
630 jsonUpdate.setTableName(tableName);
631 jsonUpdate.setValues(values);
633 Mockito.when(info.getQueryParameters()).thenReturn(row);
634 String authDatax = ":";
635 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
636 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
637 authorizationx, jsonUpdate, keyspaceName, tableName, info);
638 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
640 assertEquals(401, response.getStatus());
645 public void test5_updateTableAuthEmpty() throws Exception {
646 System.out.println("Testing update table without authentication");
649 JsonUpdate jsonUpdate = new JsonUpdate();
650 Map<String, String> consistencyInfo = new HashMap<>();
651 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
652 Map<String, Object> values = new HashMap<>();
653 row.add("emp_name", "testname");
654 values.put("emp_salary", 2500);
655 consistencyInfo.put("type", "atomic");
656 jsonUpdate.setConsistencyInfo(consistencyInfo);
657 jsonUpdate.setKeyspaceName(keyspaceName);
658 jsonUpdate.setTableName(tableName);
659 jsonUpdate.setValues(values);
661 Mockito.when(info.getQueryParameters()).thenReturn(row);
662 String authDatax =":"+password;
663 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
664 String appNamex="xx";
665 Response response = data.updateTable("1", "1", "1", "", appNamex,
666 authorizationx, jsonUpdate, keyspaceName, tableName, info);
667 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
669 assertEquals(401, response.getStatus());
674 public void test6_select() throws Exception {
675 System.out.println("Testing select");
676 createAndInsertIntoTable();
677 JsonSelect jsonSelect = new JsonSelect();
678 Map<String, String> consistencyInfo = new HashMap<>();
679 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
680 row.add("emp_name", "testname");
681 consistencyInfo.put("type", "atomic");
682 jsonSelect.setConsistencyInfo(consistencyInfo);
683 Mockito.when(info.getQueryParameters()).thenReturn(row);
684 Response response = data.select("1", "1", "1","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 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
690 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
691 assertEquals("testname", row0.get("emp_name"));
692 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
696 public void test6_selectCritical() throws Exception {
697 System.out.println("Testing select critical");
698 createAndInsertIntoTable();
699 JsonInsert jsonInsert = new JsonInsert();
700 Map<String, String> consistencyInfo = new HashMap<>();
701 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
702 row.add("emp_name", "testname");
703 consistencyInfo.put("type", "atomic");
704 jsonInsert.setConsistencyInfo(consistencyInfo);
705 Mockito.when(info.getQueryParameters()).thenReturn(row);
706 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
707 appName, authorization, jsonInsert, keyspaceName, tableName,info);
708 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
709 HashMap<String, Object> result = map.get("result");
710 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
712 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
713 assertEquals("testname", row0.get("emp_name"));
714 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
718 public void test6_deleteFromTable() throws Exception {
719 System.out.println("Testing delete from table");
720 createAndInsertIntoTable();
721 JsonDelete jsonDelete = new JsonDelete();
722 Map<String, String> consistencyInfo = new HashMap<>();
723 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
724 row.add("emp_name", "test1");
725 consistencyInfo.put("type", "atomic");
726 jsonDelete.setConsistencyInfo(consistencyInfo);
727 Mockito.when(info.getQueryParameters()).thenReturn(row);
728 Response response = data.deleteFromTable("1", "1", "1",
729 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
730 jsonDelete, keyspaceName, tableName, info);
731 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
733 assertEquals(200, response.getStatus());
739 public void test6_deleteFromTable1() throws Exception {
740 System.out.println("Testing delete from table missing delete object");
741 createAndInsertIntoTable();
743 JsonDelete jsonDelete = new JsonDelete();
744 Map<String, String> consistencyInfo = new HashMap<>();
745 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
746 consistencyInfo.put("type", "atomic");
747 jsonDelete.setConsistencyInfo(consistencyInfo);
748 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
749 Mockito.when(info.getQueryParameters()).thenReturn(row);
750 Response response = data.deleteFromTable("1", "1", "1",
751 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
752 jsonDelete, keyspaceName, tableName, info);
753 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
755 assertEquals(400, response.getStatus());
760 public void test6_deleteFromTable2() throws Exception {
761 System.out.println("Testing delete from table missing delete object");
762 createAndInsertIntoTable();
763 JsonDelete jsonDelete = new JsonDelete();
764 Map<String, String> consistencyInfo = new HashMap<>();
765 consistencyInfo.put("type", "atomic");
766 jsonDelete.setConsistencyInfo(consistencyInfo);
767 Response response = data.deleteFromTable("1", "1", "1",
768 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
769 null, keyspaceName, tableName, info);
770 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
772 assertEquals(400, response.getStatus());
776 public void test7_dropTable() throws Exception {
777 System.out.println("Testing drop table");
779 JsonTable jsonTable = new JsonTable();
780 Map<String, String> consistencyInfo = new HashMap<>();
781 consistencyInfo.put("type", "atomic");
782 jsonTable.setConsistencyInfo(consistencyInfo);
783 Response response = data.dropTable("1", "1", "1",
784 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
785 keyspaceName, tableName);
786 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
788 assertEquals(200, response.getStatus());
793 public void test8_deleteKeyspace() throws Exception {
794 System.out.println("Testing drop keyspace");
796 JsonKeySpace jsonKeyspace = new JsonKeySpace();
797 Map<String, String> consistencyInfo = new HashMap<>();
798 Map<String, Object> replicationInfo = new HashMap<>();
799 consistencyInfo.put("type", "eventual");
800 replicationInfo.put("class", "SimpleStrategy");
801 replicationInfo.put("replication_factor", 1);
802 jsonKeyspace.setConsistencyInfo(consistencyInfo);
803 jsonKeyspace.setDurabilityOfWrites("true");
804 jsonKeyspace.setKeyspaceName("TestApp1");
805 jsonKeyspace.setReplicationInfo(replicationInfo);
806 Response response = data.dropKeySpace("1", "1", "1",
807 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,appName, keyspaceName);
808 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
810 assertEquals(400, response.getStatus());
813 private static void createAdminTable() throws Exception {
814 testObject = new PreparedQueryObject();
815 testObject.appendQueryString(CassandraCQL.createAdminKeyspace);
816 MusicCore.eventualPut(testObject);
817 testObject = new PreparedQueryObject();
818 testObject.appendQueryString(CassandraCQL.createAdminTable);
819 MusicCore.eventualPut(testObject);
821 testObject = new PreparedQueryObject();
822 testObject.appendQueryString(
823 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
824 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
825 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
826 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
827 MusicUtil.DEFAULTKEYSPACENAME));
828 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
829 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
830 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
831 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
832 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
833 MusicCore.eventualPut(testObject);
835 testObject = new PreparedQueryObject();
836 testObject.appendQueryString(
837 "select uuid from admin.keyspace_master where application_name = ? allow filtering");
838 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
839 ResultSet rs = MusicCore.get(testObject);
840 List<Row> rows = rs.all();
841 if (rows.size() > 0) {
842 System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
847 private static void createKeyspace() throws Exception {
848 //shouldn't really be doing this here, but create keyspace is currently turned off
849 PreparedQueryObject query = new PreparedQueryObject();
850 query.appendQueryString(CassandraCQL.createKeySpace);
851 MusicCore.eventualPut(query);
853 boolean isAAF = false;
854 String hashedpwd = BCrypt.hashpw(password, BCrypt.gensalt());
855 query = new PreparedQueryObject();
856 query.appendQueryString(
857 "INSERT into admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
858 + "password, username, is_aaf) values (?,?,?,?,?,?,?)");
859 query.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
860 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), keyspaceName));
861 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
862 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
863 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), hashedpwd));
864 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
865 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
866 CachingUtil.updateMusicCache(keyspaceName, appName);
867 CachingUtil.updateMusicValidateCache(appName, userId, hashedpwd);
868 MusicCore.eventualPut(query);
871 private void clearAllTablesFromKeyspace() throws MusicServiceException {
872 ArrayList<String> tableNames = new ArrayList<>();
873 PreparedQueryObject query = new PreparedQueryObject();
874 query.appendQueryString("SELECT table_name FROM system_schema.tables WHERE keyspace_name = '"+keyspaceName+"';");
875 ResultSet rs = MusicCore.get(query);
877 tableNames.add(row.getString("table_name"));
879 for (String table: tableNames) {
880 query = new PreparedQueryObject();
881 query.appendQueryString("DROP TABLE " + keyspaceName + "." + table);
882 MusicCore.eventualPut(query);
887 * Create a table {@link tableName} in {@link keyspaceName}
890 private void createTable() throws Exception {
891 JsonTable jsonTable = new JsonTable();
892 Map<String, String> consistencyInfo = new HashMap<>();
893 Map<String, String> fields = new HashMap<>();
894 fields.put("uuid", "text");
895 fields.put("emp_name", "text");
896 fields.put("emp_salary", "varint");
897 fields.put("PRIMARY KEY", "(emp_name)");
898 consistencyInfo.put("type", "eventual");
899 jsonTable.setConsistencyInfo(consistencyInfo);
900 jsonTable.setKeyspaceName(keyspaceName);
901 jsonTable.setPrimaryKey("emp_name");
902 jsonTable.setTableName(tableName);
903 jsonTable.setFields(fields);
904 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
905 Response response = data.createTable("1", "1", "1",
906 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
907 jsonTable, keyspaceName, tableName);
911 * Create table {@link createTable} and insert into said table
914 private void createAndInsertIntoTable() throws Exception {
917 JsonInsert jsonInsert = new JsonInsert();
918 Map<String, String> consistencyInfo = new HashMap<>();
919 Map<String, Object> values = new HashMap<>();
920 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
921 values.put("emp_name", "testname");
922 values.put("emp_salary", 500);
923 consistencyInfo.put("type", "eventual");
924 jsonInsert.setConsistencyInfo(consistencyInfo);
925 jsonInsert.setKeyspaceName(keyspaceName);
926 jsonInsert.setTableName(tableName);
927 jsonInsert.setValues(values);
928 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
929 appName, authorization, jsonInsert, keyspaceName, tableName);