2 * ============LICENSE_START========================================== org.onap.music
3 * =================================================================== Copyright (c) 2017 AT&T Intellectual Property
4 * =================================================================== Licensed under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the
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 is distributed on
11 * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
12 * specific language governing permissions and limitations under the License.
14 * ============LICENSE_END=============================================
15 * ====================================================================
18 package org.onap.music.unittests;
20 import static org.junit.Assert.assertEquals;
21 import java.math.BigInteger;
22 import java.util.ArrayList;
23 import java.util.HashMap;
24 import java.util.List;
26 import java.util.UUID;
27 import javax.servlet.http.HttpServletResponse;
28 import javax.ws.rs.core.MultivaluedHashMap;
29 import javax.ws.rs.core.MultivaluedMap;
30 import javax.ws.rs.core.Response;
31 import javax.ws.rs.core.UriInfo;
32 import org.junit.After;
33 import org.junit.AfterClass;
34 import org.junit.BeforeClass;
35 import org.junit.Ignore;
36 import org.junit.Test;
37 import org.junit.runner.RunWith;
38 import org.mindrot.jbcrypt.BCrypt;
39 import org.mockito.Mock;
40 import org.mockito.Mockito;
41 import org.mockito.junit.MockitoJUnitRunner;
42 import org.onap.music.authentication.CachingUtil;
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.MusicCore;
53 import org.onap.music.main.MusicUtil;
54 import org.onap.music.main.ResultType;
55 import org.onap.music.rest.RestMusicDataAPI;
56 import com.datastax.driver.core.DataType;
57 import com.datastax.driver.core.ResultSet;
58 import com.datastax.driver.core.Row;
59 import com.sun.jersey.core.util.Base64;
60 import com.sun.jersey.core.util.MultivaluedMapImpl;
62 @RunWith(MockitoJUnitRunner.class)
63 public class TstRestMusicDataAPI {
65 RestMusicDataAPI data = new RestMusicDataAPI();
66 static PreparedQueryObject testObject;
69 HttpServletResponse http;
74 static String appName = "TestApp";
75 static String userId = "TestUser";
76 static String password = "TestPassword";
77 static String authData = userId + ":" + password;
78 static String wrongAuthData = userId + ":" + "pass";
79 static String authorization = new String(Base64.encode(authData.getBytes()));
80 static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
81 static boolean isAAF = false;
82 static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
83 static String keyspaceName = "testcassa";
84 static String tableName = "employees";
85 static String xLatestVersion = "X-latestVersion";
86 static String onboardUUID = null;
89 public static void init() throws Exception {
90 System.out.println("Testing RestMusicData class");
93 } catch (Exception e) {
95 throw new Exception("Unable to initialize before TestRestMusicData test class. " + e.getMessage());
100 public void afterEachTest() throws MusicServiceException {
101 clearAllTablesFromKeyspace();
105 public static void tearDownAfterClass() throws Exception {
106 testObject = new PreparedQueryObject();
107 testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
108 MusicCore.eventualPut(testObject);
112 public void test1_createKeyspace() throws Exception {
113 System.out.println("Testing create keyspace");
114 JsonKeySpace jsonKeyspace = new JsonKeySpace();
115 Map<String, String> consistencyInfo = new HashMap<>();
116 Map<String, Object> replicationInfo = new HashMap<>();
117 consistencyInfo.put("type", "eventual");
118 replicationInfo.put("class", "SimpleStrategy");
119 replicationInfo.put("replication_factor", 1);
120 jsonKeyspace.setConsistencyInfo(consistencyInfo);
121 jsonKeyspace.setDurabilityOfWrites("true");
122 jsonKeyspace.setKeyspaceName(keyspaceName);
123 jsonKeyspace.setReplicationInfo(replicationInfo);
124 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
126 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", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
150 authorization, jsonTable, keyspaceName, tableName);
151 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
152 assertEquals(200, response.getStatus());
156 public void test3_createTableNoName() throws Exception {
157 System.out.println("Testing create table without name");
158 JsonTable jsonTable = new JsonTable();
159 Map<String, String> consistencyInfo = new HashMap<>();
160 Map<String, String> fields = new HashMap<>();
161 fields.put("uuid", "text");
162 fields.put("emp_name", "text");
163 fields.put("emp_salary", "varint");
164 fields.put("PRIMARY KEY", "(emp_name)");
165 consistencyInfo.put("type", "eventual");
166 jsonTable.setConsistencyInfo(consistencyInfo);
167 jsonTable.setKeyspaceName(keyspaceName);
168 jsonTable.setPrimaryKey("emp_name");
169 jsonTable.setTableName("");
170 jsonTable.setFields(fields);
171 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
172 authorization, jsonTable, keyspaceName, "");
173 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
174 assertEquals(400, response.getStatus());
179 public void test3_createTableClusterOrderBad() throws Exception {
180 System.out.println("Testing create table bad clustering");
181 JsonTable jsonTable = new JsonTable();
182 Map<String, String> consistencyInfo = new HashMap<>();
183 Map<String, String> fields = new HashMap<>();
184 fields.put("uuid", "text");
185 fields.put("emp_name", "text");
186 fields.put("emp_salary", "varint");
187 fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
188 consistencyInfo.put("type", "eventual");
189 jsonTable.setConsistencyInfo(consistencyInfo);
190 jsonTable.setKeyspaceName(keyspaceName);
191 jsonTable.setPrimaryKey("emp_name,emp_salary");
192 jsonTable.setClusteringOrder("ASC");
193 jsonTable.setTableName(tableName);
194 jsonTable.setFields(fields);
195 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
196 authorization, jsonTable, keyspaceName, tableName);
197 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
198 assertEquals(400, response.getStatus());
202 public void test3_createTable_withPropertiesNotNull() throws Exception {
203 System.out.println("Testing create table with properties");
204 JsonTable jsonTable = new JsonTable();
205 Map<String, String> consistencyInfo = new HashMap<>();
206 Map<String, String> fields = new HashMap<>();
207 fields.put("uuid", "text");
208 fields.put("emp_name", "text");
209 fields.put("emp_salary", "varint");
210 fields.put("PRIMARY KEY", "(emp_name)");
211 consistencyInfo.put("type", "eventual");
212 Map<String, Object> properties = new HashMap<>();
213 properties.put("comment", "Testing prperties not null");
214 jsonTable.setConsistencyInfo(consistencyInfo);
215 jsonTable.setKeyspaceName(keyspaceName);
216 jsonTable.setPrimaryKey("emp_name");
217 String tableName_prop = tableName + "_Prop";
218 jsonTable.setTableName(tableName_prop);
219 jsonTable.setFields(fields);
220 jsonTable.setProperties(properties);
222 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
223 authorization, jsonTable, keyspaceName, tableName_prop);
224 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
225 assertEquals(200, response.getStatus());
229 public void test3_createTable_duplicateTable() throws Exception {
230 System.out.println("Testing creating duplicate tables");
231 JsonTable jsonTable = new JsonTable();
232 Map<String, String> consistencyInfo = new HashMap<>();
233 Map<String, String> fields = new HashMap<>();
234 fields.put("uuid", "text");
235 fields.put("emp_name", "text");
236 fields.put("emp_salary", "varint");
237 fields.put("PRIMARY KEY", "(emp_name)");
238 consistencyInfo.put("type", "eventual");
239 jsonTable.setConsistencyInfo(consistencyInfo);
240 jsonTable.setKeyspaceName(keyspaceName);
241 jsonTable.setPrimaryKey("emp_name");
242 String tableNameDup = tableName + "x";
243 jsonTable.setTableName(tableNameDup);
244 jsonTable.setFields(fields);
245 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
246 Response response1 = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
247 authorization, jsonTable, keyspaceName, tableNameDup);
249 Response response2 = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
250 authorization, jsonTable, keyspaceName, tableNameDup);
251 System.out.println("Status: " + response2.getStatus() + ". Entity " + response2.getEntity());
253 assertEquals(400, response2.getStatus());
254 Map<String, String> respMap = (Map<String, String>) response2.getEntity();
255 assertEquals(ResultType.FAILURE, respMap.get("status"));
256 assertEquals("Table " + keyspaceName + "." + tableNameDup + " already exists", respMap.get("error"));
261 public void test3_createTable1() throws Exception {
262 System.out.println("Testing create table w/ improper authentication");
263 JsonTable jsonTable = new JsonTable();
264 Map<String, String> consistencyInfo = new HashMap<>();
265 Map<String, String> fields = new HashMap<>();
266 fields.put("uuid", "text");
267 fields.put("emp_name", "text");
268 fields.put("emp_salary", "varint");
269 fields.put("PRIMARY KEY", "(emp_name)");
270 consistencyInfo.put("type", "eventual");
271 jsonTable.setConsistencyInfo(consistencyInfo);
272 jsonTable.setKeyspaceName(keyspaceName);
273 jsonTable.setPrimaryKey("emp_name");
274 jsonTable.setTableName(tableName);
275 jsonTable.setFields(fields);
276 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
277 wrongAuthorization, jsonTable, keyspaceName, tableName);
278 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
279 assertEquals(401, response.getStatus());
284 public void test3_createTable3() throws Exception {
285 System.out.println("Testing create table for wrong keyspace");
286 JsonTable jsonTable = new JsonTable();
287 Map<String, String> consistencyInfo = new HashMap<>();
288 Map<String, String> fields = new HashMap<>();
289 fields.put("uuid", "text");
290 fields.put("emp_name", "text");
291 fields.put("emp_salary", "varint");
292 fields.put("PRIMARY KEY", "(emp_name)");
293 consistencyInfo.put("type", "eventual");
294 jsonTable.setConsistencyInfo(consistencyInfo);
295 jsonTable.setKeyspaceName(keyspaceName);
296 jsonTable.setPrimaryKey("emp_name");
297 jsonTable.setTableName(tableName);
298 jsonTable.setFields(fields);
299 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
300 authorization, jsonTable, "wrong", tableName);
301 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
302 assertEquals(401, response.getStatus());
305 // Improper parenthesis in key field
307 public void test3_createTable_badParantesis() throws Exception {
308 System.out.println("Testing malformed create table request");
309 String tableNameC = "testTable0";
310 JsonTable jsonTable = new JsonTable();
311 Map<String, String> consistencyInfo = new HashMap<>();
312 Map<String, String> fields = new HashMap<>();
313 fields.put("uuid", "text");
314 fields.put("emp_name", "text");
315 fields.put("emp_salary", "varint");
316 fields.put("PRIMARY KEY", "(emp_name),emp_id)");
317 fields.put("emp_id", "varint");
318 consistencyInfo.put("type", "eventual");
319 jsonTable.setConsistencyInfo(consistencyInfo);
320 jsonTable.setKeyspaceName(keyspaceName);
321 jsonTable.setPrimaryKey("emp_name");
322 jsonTable.setTableName(tableNameC);
323 jsonTable.setClusteringOrder("emp_id Desc");
324 jsonTable.setFields(fields);
325 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
326 authorization, jsonTable, keyspaceName, tableNameC);
327 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
329 assertEquals(400, response.getStatus());
333 // good clustering key
335 public void test3_createTable_1_clusterKey_good() throws Exception {
336 System.out.println("Testing create w/ clusterKey");
338 String tableNameC = "testTableC1";
339 JsonTable jsonTable = new JsonTable();
340 Map<String, String> consistencyInfo = new HashMap<>();
341 Map<String, String> fields = new HashMap<>();
342 fields.put("uuid", "text");
343 fields.put("emp_name", "text");
344 fields.put("emp_salary", "varint");
345 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
346 consistencyInfo.put("type", "eventual");
347 jsonTable.setConsistencyInfo(consistencyInfo);
348 jsonTable.setKeyspaceName(keyspaceName);
349 // jsonTable.setPrimaryKey("emp_name");
350 jsonTable.setTableName(tableNameC);
351 jsonTable.setClusteringOrder("emp_salary ASC");
352 jsonTable.setFields(fields);
353 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
354 authorization, jsonTable, keyspaceName, tableNameC);
355 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
357 assertEquals(200, response.getStatus());
360 // bad partition key=clustering key
362 public void test3_createTable_2_clusterKey_bad() throws Exception {
363 System.out.println("Testing create w/ bad clusterKey");
364 String tableNameC = "testTableC2";
365 JsonTable jsonTable = new JsonTable();
366 Map<String, String> consistencyInfo = new HashMap<>();
367 Map<String, String> fields = new HashMap<>();
368 fields.put("uuid", "text");
369 fields.put("emp_name", "text");
370 fields.put("emp_salary", "varint");
371 fields.put("PRIMARY KEY", "((emp_name),emp_name)");
372 consistencyInfo.put("type", "eventual");
373 jsonTable.setConsistencyInfo(consistencyInfo);
374 jsonTable.setKeyspaceName(keyspaceName);
375 jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
376 jsonTable.setTableName(tableNameC);
377 jsonTable.setClusteringOrder("emp_salary ASC");
378 jsonTable.setFields(fields);
379 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
380 authorization, jsonTable, keyspaceName, tableNameC);
381 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
383 assertEquals(400, response.getStatus());
386 // good composite partition key,clustering key
388 public void test3_createTable_3_pfartition_clusterKey_good() throws Exception {
389 System.out.println("Testing create w/ composite partition key, clusterKey");
391 String tableNameC = "testTableC3";
392 JsonTable jsonTable = new JsonTable();
393 Map<String, String> consistencyInfo = new HashMap<>();
394 Map<String, String> fields = new HashMap<>();
395 fields.put("uuid", "text");
396 fields.put("emp_name", "text");
397 fields.put("emp_id", "varint");
398 fields.put("emp_salary", "varint");
399 fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
400 consistencyInfo.put("type", "eventual");
401 jsonTable.setConsistencyInfo(consistencyInfo);
402 jsonTable.setKeyspaceName(keyspaceName);
403 jsonTable.setPrimaryKey("emp_name");
404 jsonTable.setTableName(tableNameC);
405 jsonTable.setClusteringOrder("emp_salary ASC");
406 jsonTable.setFields(fields);
407 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
408 authorization, jsonTable, keyspaceName, tableNameC);
409 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
411 assertEquals(200, response.getStatus());
414 // bad - wrong cols in order by of composite partition key,clustering key
416 public void test3_createTable_5_clusteringOrder_bad() throws Exception {
417 System.out.println("Testing create table bad request with clustering & composite keys");
418 String tableNameC = "testTableC5";
419 JsonTable jsonTable = new JsonTable();
420 Map<String, String> consistencyInfo = new HashMap<>();
421 Map<String, String> fields = new HashMap<>();
422 fields.put("uuid", "text");
423 fields.put("emp_name", "text");
424 fields.put("emp_id", "varint");
425 fields.put("emp_salary", "varint");
426 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
427 consistencyInfo.put("type", "eventual");
428 jsonTable.setConsistencyInfo(consistencyInfo);
429 jsonTable.setKeyspaceName(keyspaceName);
430 jsonTable.setPrimaryKey("emp_name");
431 jsonTable.setTableName(tableNameC);
432 jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
433 jsonTable.setFields(fields);
434 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
435 authorization, jsonTable, keyspaceName, tableNameC);
436 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
438 assertEquals(400, response.getStatus());
443 public void test3_createTablePartitionKey() throws Exception {
444 System.out.println("Testing create table with a partitionKey");
445 JsonTable jsonTable = new JsonTable();
446 Map<String, String> consistencyInfo = new HashMap<>();
447 Map<String, String> fields = new HashMap<>();
448 fields.put("uuid", "text");
449 fields.put("emp_name", "text");
450 fields.put("emp_salary", "varint");
451 fields.put("PRIMARY KEY", "(emp_name)");
452 consistencyInfo.put("type", "eventual");
453 jsonTable.setConsistencyInfo(consistencyInfo);
454 jsonTable.setKeyspaceName(keyspaceName);
455 jsonTable.setPrimaryKey("emp_name");
456 jsonTable.setTableName(tableName);
457 jsonTable.setFields(fields);
458 jsonTable.setPartitionKey("emp_salary");
459 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
460 authorization, jsonTable, keyspaceName, tableName);
461 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
462 assertEquals(200, response.getStatus());
465 // good clustering key, need to pass queryparameter
467 public void test3_createTableIndex_1() throws Exception {
468 System.out.println("Testing index in create table");
469 String tableNameC = "testTableCinx";
470 JsonTable jsonTable = new JsonTable();
471 Map<String, String> consistencyInfo = new HashMap<>();
472 Map<String, String> fields = new HashMap<>();
473 fields.put("uuid", "text");
474 fields.put("emp_name", "text");
475 fields.put("emp_salary", "varint");
476 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
477 consistencyInfo.put("type", "eventual");
478 jsonTable.setConsistencyInfo(consistencyInfo);
479 jsonTable.setKeyspaceName(keyspaceName);
480 jsonTable.setTableName(tableNameC);
481 jsonTable.setClusteringOrder("emp_salary ASC");
482 jsonTable.setFields(fields);
483 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
484 authorization, jsonTable, keyspaceName, tableNameC);
485 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
486 // info.setQueryParameters("index_name=inx_uuid");
487 Map<String, String> queryParametersMap = new HashMap<String, String>();
489 queryParametersMap.put("index_name", "inxuuid");
490 Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedHashMap<String, String>(queryParametersMap));
491 response = data.createIndex("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
492 keyspaceName, tableNameC, "uuid", info);
493 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
495 assertEquals(200, response.getStatus());
498 // create index without table name
500 public void test3_createTableIndexNoName() throws Exception {
501 System.out.println("Testing index in create table w/o tablename");
502 String tableNameC = "testTableCinx";
503 JsonTable jsonTable = new JsonTable();
504 Map<String, String> consistencyInfo = new HashMap<>();
505 Map<String, String> fields = new HashMap<>();
506 fields.put("uuid", "text");
507 fields.put("emp_name", "text");
508 fields.put("emp_salary", "varint");
509 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
510 consistencyInfo.put("type", "eventual");
511 jsonTable.setConsistencyInfo(consistencyInfo);
512 jsonTable.setKeyspaceName(keyspaceName);
513 jsonTable.setTableName(tableNameC);
514 jsonTable.setClusteringOrder("emp_salary ASC");
515 jsonTable.setFields(fields);
516 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
517 authorization, jsonTable, keyspaceName, tableNameC);
518 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
519 // info.setQueryParameters("index_name=inx_uuid");
520 Map<String, String> queryParametersMap = new HashMap<String, String>();
522 queryParametersMap.put("index_name", "inxuuid");
523 response = data.createIndex("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization, "",
525 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
527 assertEquals(400, response.getStatus());
531 public void test4_insertIntoTable() throws Exception {
532 System.out.println("Testing insert into table");
534 JsonInsert jsonInsert = new JsonInsert();
535 Map<String, String> consistencyInfo = new HashMap<>();
536 Map<String, Object> values = new HashMap<>();
537 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
538 values.put("emp_name", "testname");
539 values.put("emp_salary", 500);
540 consistencyInfo.put("type", "eventual");
541 jsonInsert.setConsistencyInfo(consistencyInfo);
542 jsonInsert.setKeyspaceName(keyspaceName);
543 jsonInsert.setTableName(tableName);
544 jsonInsert.setValues(values);
545 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
546 authorization, jsonInsert, keyspaceName, tableName);
547 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
549 assertEquals(200, response.getStatus());
553 public void test4_insertIntoTableCriticalNoLockID() throws Exception {
554 System.out.println("Testing atomic insert into table without lockid");
556 JsonInsert jsonInsert = new JsonInsert();
557 Map<String, String> consistencyInfo = new HashMap<>();
558 Map<String, Object> values = new HashMap<>();
559 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
560 values.put("emp_name", "testname");
561 values.put("emp_salary", 500);
562 consistencyInfo.put("type", "critical");
563 jsonInsert.setConsistencyInfo(consistencyInfo);
564 jsonInsert.setKeyspaceName(keyspaceName);
565 jsonInsert.setTableName(tableName);
566 jsonInsert.setValues(values);
567 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
568 authorization, jsonInsert, keyspaceName, tableName);
569 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
571 assertEquals(400, response.getStatus());
575 public void test4_insertIntoTableNoName() throws Exception {
576 System.out.println("Testing insert into table w/o table name");
578 JsonInsert jsonInsert = new JsonInsert();
579 Map<String, String> consistencyInfo = new HashMap<>();
580 Map<String, Object> values = new HashMap<>();
581 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
582 values.put("emp_name", "testname");
583 values.put("emp_salary", 500);
584 consistencyInfo.put("type", "eventual");
585 jsonInsert.setConsistencyInfo(consistencyInfo);
586 jsonInsert.setKeyspaceName(keyspaceName);
587 jsonInsert.setTableName(tableName);
588 jsonInsert.setValues(values);
589 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
590 authorization, jsonInsert, "", "");
591 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
593 assertEquals(400, response.getStatus());
597 public void test4_insertIntoTable2() throws Exception {
598 System.out.println("Testing insert into table #2");
600 JsonInsert jsonInsert = new JsonInsert();
601 Map<String, String> consistencyInfo = new HashMap<>();
602 Map<String, Object> values = new HashMap<>();
603 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
604 values.put("emp_name", "test1");
605 values.put("emp_salary", 1500);
606 consistencyInfo.put("type", "eventual");
607 jsonInsert.setConsistencyInfo(consistencyInfo);
608 jsonInsert.setKeyspaceName(keyspaceName);
609 jsonInsert.setTableName(tableName);
610 jsonInsert.setValues(values);
611 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
612 authorization, jsonInsert, keyspaceName, tableName);
613 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
615 assertEquals(200, response.getStatus());
620 public void test4_insertIntoTable3() throws Exception {
621 System.out.println("Testing insert into table with bad credentials");
623 JsonInsert jsonInsert = new JsonInsert();
624 Map<String, String> consistencyInfo = new HashMap<>();
625 Map<String, Object> values = new HashMap<>();
626 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
627 values.put("emp_name", "test1");
628 values.put("emp_salary", 1500);
629 consistencyInfo.put("type", "eventual");
630 jsonInsert.setConsistencyInfo(consistencyInfo);
631 jsonInsert.setKeyspaceName(keyspaceName);
632 jsonInsert.setTableName(tableName);
633 jsonInsert.setValues(values);
634 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
635 wrongAuthorization, jsonInsert, keyspaceName, tableName);
636 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
638 assertEquals(401, response.getStatus());
643 public void test4_insertIntoTable4() throws Exception {
644 System.out.println("Testing insert into wrong table");
646 JsonInsert jsonInsert = new JsonInsert();
647 Map<String, String> consistencyInfo = new HashMap<>();
648 Map<String, Object> values = new HashMap<>();
649 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
650 values.put("emp_name", "test1");
651 values.put("emp_salary", 1500);
652 consistencyInfo.put("type", "eventual");
653 jsonInsert.setConsistencyInfo(consistencyInfo);
654 jsonInsert.setKeyspaceName(keyspaceName);
655 jsonInsert.setTableName(tableName);
656 jsonInsert.setValues(values);
657 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
658 authorization, jsonInsert, keyspaceName, "wrong");
659 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
661 assertEquals(400, response.getStatus());
665 public void test4_insertBlobIntoTable() throws Exception {
666 System.out.println("Testing insert a blob into table");
668 JsonInsert jsonInsert = new JsonInsert();
669 Map<String, String> consistencyInfo = new HashMap<>();
670 Map<String, Object> values = new HashMap<>();
671 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
672 values.put("emp_name", "testname");
673 values.put("emp_salary", 500);
674 values.put("binary", "somestuffhere");
675 consistencyInfo.put("type", "eventual");
676 jsonInsert.setConsistencyInfo(consistencyInfo);
677 jsonInsert.setKeyspaceName(keyspaceName);
678 jsonInsert.setTableName(tableName);
679 jsonInsert.setValues(values);
680 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
681 authorization, jsonInsert, keyspaceName, tableName);
682 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
684 assertEquals(200, response.getStatus());
688 public void test5_updateTable() throws Exception {
689 System.out.println("Testing update table");
692 JsonUpdate jsonUpdate = new JsonUpdate();
693 Map<String, String> consistencyInfo = new HashMap<>();
694 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
695 Map<String, Object> values = new HashMap<>();
696 row.add("emp_name", "testname");
697 values.put("emp_salary", 2500);
698 consistencyInfo.put("type", "atomic");
699 jsonUpdate.setConsistencyInfo(consistencyInfo);
700 jsonUpdate.setKeyspaceName(keyspaceName);
701 jsonUpdate.setTableName(tableName);
702 jsonUpdate.setValues(values);
703 Mockito.when(info.getQueryParameters()).thenReturn(row);
704 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
705 authorization, jsonUpdate, keyspaceName, tableName, info);
707 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
709 assertEquals(200, response.getStatus());
713 public void test5_updateTableNoName() throws Exception {
714 System.out.println("Testing update table without tablename");
717 JsonUpdate jsonUpdate = new JsonUpdate();
718 Map<String, String> consistencyInfo = new HashMap<>();
719 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
720 Map<String, Object> values = new HashMap<>();
721 row.add("emp_name", "testname");
722 values.put("emp_salary", 2500);
723 consistencyInfo.put("type", "atomic");
724 jsonUpdate.setConsistencyInfo(consistencyInfo);
725 jsonUpdate.setKeyspaceName(keyspaceName);
726 jsonUpdate.setTableName(tableName);
727 jsonUpdate.setValues(values);
728 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
729 authorization, jsonUpdate, "", "", info);
731 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
733 assertEquals(400, response.getStatus());
736 // need mock code to create error for MusicCore methods
738 public void test5_updateTableAuthE() throws Exception {
739 System.out.println("Testing update table #2");
741 // MockitoAnnotations.initMocks(this);
742 JsonUpdate jsonUpdate = new JsonUpdate();
743 Map<String, String> consistencyInfo = new HashMap<>();
744 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
745 Map<String, Object> values = new HashMap<>();
746 row.add("emp_name", "testname");
747 values.put("emp_salary", 2500);
748 consistencyInfo.put("type", "atomic");
749 jsonUpdate.setConsistencyInfo(consistencyInfo);
750 jsonUpdate.setKeyspaceName(keyspaceName);
751 jsonUpdate.setTableName(tableName);
752 jsonUpdate.setValues(values);
753 // add ttl & timestamp
754 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
755 Mockito.when(info.getQueryParameters()).thenReturn(row);
756 // Map<String, Object> m1= new HashMap<>() ;
757 // Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
758 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
759 authorization, jsonUpdate, keyspaceName, tableName, info);
760 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
762 assertEquals(200, response.getStatus());
767 public void test5_updateTableAuthException1() throws Exception {
768 System.out.println("Testing update table authentication error");
770 JsonUpdate jsonUpdate = new JsonUpdate();
771 Map<String, String> consistencyInfo = new HashMap<>();
772 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
773 Map<String, Object> values = new HashMap<>();
774 row.add("emp_name", "testname");
775 values.put("emp_salary", 2500);
776 consistencyInfo.put("type", "atomic");
777 jsonUpdate.setConsistencyInfo(consistencyInfo);
778 jsonUpdate.setKeyspaceName(keyspaceName);
779 jsonUpdate.setTableName(tableName);
780 jsonUpdate.setValues(values);
782 Mockito.when(info.getQueryParameters()).thenReturn(row);
783 String authDatax = ":";
784 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
785 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
786 authorizationx, jsonUpdate, keyspaceName, tableName, info);
787 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
789 assertEquals(401, response.getStatus());
794 public void test5_updateTableAuthEmpty() throws Exception {
795 System.out.println("Testing update table without authentication");
798 JsonUpdate jsonUpdate = new JsonUpdate();
799 Map<String, String> consistencyInfo = new HashMap<>();
800 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
801 Map<String, Object> values = new HashMap<>();
802 row.add("emp_name", "testname");
803 values.put("emp_salary", 2500);
804 consistencyInfo.put("type", "atomic");
805 jsonUpdate.setConsistencyInfo(consistencyInfo);
806 jsonUpdate.setKeyspaceName(keyspaceName);
807 jsonUpdate.setTableName(tableName);
808 jsonUpdate.setValues(values);
810 Mockito.when(info.getQueryParameters()).thenReturn(row);
811 String authDatax = ":" + password;
812 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
813 String appNamex = "xx";
814 Response response = data.updateTable("1", "1", "1", "", appNamex, authorizationx, jsonUpdate, keyspaceName,
816 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
818 assertEquals(401, response.getStatus());
823 public void test6_select() throws Exception {
824 System.out.println("Testing select");
825 createAndInsertIntoTable();
826 JsonSelect jsonSelect = new JsonSelect();
827 Map<String, String> consistencyInfo = new HashMap<>();
828 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
829 row.add("emp_name", "testname");
830 consistencyInfo.put("type", "atomic");
831 jsonSelect.setConsistencyInfo(consistencyInfo);
832 Mockito.when(info.getQueryParameters()).thenReturn(row);
833 Response response = data.select("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
834 keyspaceName, tableName, info);
835 HashMap<String, HashMap<String, Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
836 HashMap<String, Object> result = map.get("result");
837 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
839 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
840 assertEquals("testname", row0.get("emp_name"));
841 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
845 public void test6_selectCritical() throws Exception {
846 System.out.println("Testing select critical");
847 createAndInsertIntoTable();
848 JsonInsert jsonInsert = new JsonInsert();
849 Map<String, String> consistencyInfo = new HashMap<>();
850 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
851 row.add("emp_name", "testname");
852 consistencyInfo.put("type", "atomic");
853 jsonInsert.setConsistencyInfo(consistencyInfo);
854 Mockito.when(info.getQueryParameters()).thenReturn(row);
855 Response response = data.selectCritical("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
856 authorization, jsonInsert, keyspaceName, tableName, info);
857 HashMap<String, HashMap<String, Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
858 HashMap<String, Object> result = map.get("result");
859 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
861 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
862 assertEquals("testname", row0.get("emp_name"));
863 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
867 public void test6_deleteFromTable() throws Exception {
868 System.out.println("Testing delete from table");
869 createAndInsertIntoTable();
870 JsonDelete jsonDelete = new JsonDelete();
871 Map<String, String> consistencyInfo = new HashMap<>();
872 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
873 row.add("emp_name", "test1");
874 consistencyInfo.put("type", "atomic");
875 jsonDelete.setConsistencyInfo(consistencyInfo);
876 Mockito.when(info.getQueryParameters()).thenReturn(row);
877 Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
878 authorization, jsonDelete, keyspaceName, tableName, info);
879 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
881 assertEquals(200, response.getStatus());
887 public void test6_deleteFromTable1() throws Exception {
888 System.out.println("Testing delete from table missing delete object");
889 createAndInsertIntoTable();
891 JsonDelete jsonDelete = new JsonDelete();
892 Map<String, String> consistencyInfo = new HashMap<>();
893 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
894 consistencyInfo.put("type", "atomic");
895 jsonDelete.setConsistencyInfo(consistencyInfo);
896 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
897 Mockito.when(info.getQueryParameters()).thenReturn(row);
898 Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
899 authorization, jsonDelete, keyspaceName, tableName, info);
900 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
902 assertEquals(400, response.getStatus());
907 public void test6_deleteFromTable2() throws Exception {
908 System.out.println("Testing delete from table missing delete object");
909 createAndInsertIntoTable();
910 JsonDelete jsonDelete = new JsonDelete();
911 Map<String, String> consistencyInfo = new HashMap<>();
912 consistencyInfo.put("type", "atomic");
913 jsonDelete.setConsistencyInfo(consistencyInfo);
914 Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
915 authorization, null, keyspaceName, tableName, info);
916 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
918 assertEquals(400, response.getStatus());
922 public void test7_dropTable() throws Exception {
923 System.out.println("Testing drop table");
925 JsonTable jsonTable = new JsonTable();
926 Map<String, String> consistencyInfo = new HashMap<>();
927 consistencyInfo.put("type", "atomic");
928 jsonTable.setConsistencyInfo(consistencyInfo);
929 Response response = data.dropTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
930 authorization, keyspaceName, tableName);
931 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
933 assertEquals(200, response.getStatus());
938 public void test8_deleteKeyspace() throws Exception {
939 System.out.println("Testing drop keyspace");
941 JsonKeySpace jsonKeyspace = new JsonKeySpace();
942 Map<String, String> consistencyInfo = new HashMap<>();
943 Map<String, Object> replicationInfo = new HashMap<>();
944 consistencyInfo.put("type", "eventual");
945 replicationInfo.put("class", "SimpleStrategy");
946 replicationInfo.put("replication_factor", 1);
947 jsonKeyspace.setConsistencyInfo(consistencyInfo);
948 jsonKeyspace.setDurabilityOfWrites("true");
949 jsonKeyspace.setKeyspaceName("TestApp1");
950 jsonKeyspace.setReplicationInfo(replicationInfo);
951 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,
952 appName, keyspaceName);
953 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
955 assertEquals(400, response.getStatus());
958 private static void createKeyspace() throws Exception {
959 // shouldn't really be doing this here, but create keyspace is currently turned off
960 PreparedQueryObject query = new PreparedQueryObject();
961 query.appendQueryString(CassandraCQL.createKeySpace);
962 MusicCore.eventualPut(query);
964 boolean isAAF = false;
965 String hashedpwd = BCrypt.hashpw(password, BCrypt.gensalt());
966 query = new PreparedQueryObject();
967 query.appendQueryString("INSERT into admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
968 + "password, username, is_aaf) values (?,?,?,?,?,?,?)");
969 query.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
970 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), keyspaceName));
971 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
972 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
973 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), hashedpwd));
974 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
975 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
976 CachingUtil.updateMusicCache(keyspaceName, appName);
977 CachingUtil.updateMusicValidateCache(appName, userId, hashedpwd);
978 MusicCore.eventualPut(query);
981 private void clearAllTablesFromKeyspace() throws MusicServiceException {
982 ArrayList<String> tableNames = new ArrayList<>();
983 PreparedQueryObject query = new PreparedQueryObject();
984 query.appendQueryString(
985 "SELECT table_name FROM system_schema.tables WHERE keyspace_name = '" + keyspaceName + "';");
986 ResultSet rs = MusicCore.get(query);
988 tableNames.add(row.getString("table_name"));
990 for (String table : tableNames) {
991 query = new PreparedQueryObject();
992 query.appendQueryString("DROP TABLE " + keyspaceName + "." + table);
993 MusicCore.eventualPut(query);
998 * Create a table {@link tableName} in {@link keyspaceName}
1002 private void createTable() throws Exception {
1003 JsonTable jsonTable = new JsonTable();
1004 Map<String, String> consistencyInfo = new HashMap<>();
1005 Map<String, String> fields = new HashMap<>();
1006 fields.put("uuid", "text");
1007 fields.put("emp_name", "text");
1008 fields.put("emp_salary", "varint");
1009 fields.put("binary", "blob");
1010 fields.put("PRIMARY KEY", "(emp_name)");
1011 consistencyInfo.put("type", "eventual");
1012 jsonTable.setConsistencyInfo(consistencyInfo);
1013 jsonTable.setKeyspaceName(keyspaceName);
1014 jsonTable.setPrimaryKey("emp_name");
1015 jsonTable.setTableName(tableName);
1016 jsonTable.setFields(fields);
1017 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1018 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1019 authorization, jsonTable, keyspaceName, tableName);
1023 * Create table {@link createTable} and insert into said table
1027 private void createAndInsertIntoTable() throws Exception {
1030 JsonInsert jsonInsert = new JsonInsert();
1031 Map<String, String> consistencyInfo = new HashMap<>();
1032 Map<String, Object> values = new HashMap<>();
1033 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1034 values.put("emp_name", "testname");
1035 values.put("emp_salary", 500);
1036 values.put("binary", "binarydatahere");
1037 consistencyInfo.put("type", "eventual");
1038 jsonInsert.setConsistencyInfo(consistencyInfo);
1039 jsonInsert.setKeyspaceName(keyspaceName);
1040 jsonInsert.setTableName(tableName);
1041 jsonInsert.setValues(values);
1042 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1043 authorization, jsonInsert, keyspaceName, tableName);