2 * ============LICENSE_START==========================================
4 * ===================================================================
5 * Copyright (c) 2019 AT&T Intellectual Property
6 * ===================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 * ============LICENSE_END=============================================
20 * ====================================================================
23 package org.onap.music.unittests;
25 import static org.junit.Assert.assertEquals;
26 import java.math.BigInteger;
27 import java.util.ArrayList;
28 import java.util.HashMap;
29 import java.util.List;
31 import java.util.UUID;
32 import javax.servlet.http.HttpServletResponse;
33 import javax.ws.rs.core.MultivaluedHashMap;
34 import javax.ws.rs.core.MultivaluedMap;
35 import javax.ws.rs.core.Response;
36 import javax.ws.rs.core.UriInfo;
37 import org.junit.After;
38 import org.junit.AfterClass;
39 import org.junit.BeforeClass;
40 import org.junit.Ignore;
41 import org.junit.Test;
42 import org.junit.runner.RunWith;
43 import org.mindrot.jbcrypt.BCrypt;
44 import org.mockito.Mock;
45 import org.mockito.Mockito;
46 import org.mockito.junit.MockitoJUnitRunner;
47 import org.onap.music.datastore.MusicDataStoreHandle;
48 import org.onap.music.datastore.PreparedQueryObject;
49 import org.onap.music.datastore.jsonobjects.JsonDelete;
50 import org.onap.music.datastore.jsonobjects.JsonInsert;
51 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
52 import org.onap.music.datastore.jsonobjects.JsonSelect;
53 import org.onap.music.datastore.jsonobjects.JsonTable;
54 import org.onap.music.datastore.jsonobjects.JsonUpdate;
55 import org.onap.music.exceptions.MusicServiceException;
56 import org.onap.music.main.MusicCore;
57 import org.onap.music.main.MusicUtil;
58 import org.onap.music.main.ResultType;
59 import org.onap.music.rest.RestMusicDataAPI;
60 import org.onap.music.rest.RestMusicLocksAPI;
61 import com.datastax.driver.core.DataType;
62 import com.datastax.driver.core.ResultSet;
63 import com.datastax.driver.core.Row;
64 import com.sun.jersey.core.util.Base64;
65 import com.sun.jersey.core.util.MultivaluedMapImpl;
67 @RunWith(MockitoJUnitRunner.class)
68 public class TstRestMusicDataAPI {
70 RestMusicDataAPI data = new RestMusicDataAPI();
71 RestMusicLocksAPI lock = new RestMusicLocksAPI();
72 static PreparedQueryObject testObject;
75 HttpServletResponse http;
80 static String appName = "TestApp";
81 static String userId = "TestUser";
82 static String password = "TestPassword";
83 static String authData = userId + ":" + password;
84 static String wrongAuthData = userId + ":" + "pass";
85 static String authorization = new String(Base64.encode(authData.getBytes()));
86 static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
87 static boolean isAAF = false;
88 static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
89 static String keyspaceName = "testcassa";
90 static String tableName = "employees";
91 static String xLatestVersion = "X-latestVersion";
92 static String onboardUUID = null;
93 static String aid = TestsUsingCassandra.aid;
96 public static void init() throws Exception {
97 System.out.println("Testing RestMusicData class");
100 } catch (Exception e) {
102 throw new Exception("Unable to initialize before TestRestMusicData test class. " + e.getMessage());
107 public void afterEachTest() throws MusicServiceException {
108 clearAllTablesFromKeyspace();
112 public static void tearDownAfterClass() throws Exception {
113 testObject = new PreparedQueryObject();
114 testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
115 MusicCore.eventualPut(testObject);
119 public void test1_createKeyspace() throws Exception {
120 System.out.println("Testing create keyspace");
121 JsonKeySpace jsonKeyspace = new JsonKeySpace();
122 Map<String, String> consistencyInfo = new HashMap<>();
123 Map<String, Object> replicationInfo = new HashMap<>();
124 consistencyInfo.put("type", "eventual");
125 replicationInfo.put("class", "SimpleStrategy");
126 replicationInfo.put("replication_factor", 1);
127 jsonKeyspace.setConsistencyInfo(consistencyInfo);
128 jsonKeyspace.setDurabilityOfWrites("true");
129 jsonKeyspace.setKeyspaceName(keyspaceName);
130 jsonKeyspace.setReplicationInfo(replicationInfo);
131 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
133 data.createKeySpace("1", "1", "1", null, authorization, appName, jsonKeyspace, keyspaceName);
134 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
135 assertEquals(400, response.getStatus());
136 Map<String, String> respMap = (Map<String, String>) response.getEntity();
137 assertEquals(ResultType.FAILURE, respMap.get("status"));
141 public void test1_createKeyspaceSuccess() throws Exception {
142 System.out.println("Testing successful creation and deletion of keyspace");
143 MusicUtil.setKeyspaceActive(true);
145 String keyspaceToCreate = "temp"+keyspaceName;
148 JsonKeySpace jsonKeyspace = new JsonKeySpace();
149 Map<String, String> consistencyInfo = new HashMap<>();
150 Map<String, Object> replicationInfo = new HashMap<>();
151 consistencyInfo.put("type", "eventual");
152 replicationInfo.put("class", "SimpleStrategy");
153 replicationInfo.put("replication_factor", 1);
154 jsonKeyspace.setConsistencyInfo(consistencyInfo);
155 jsonKeyspace.setDurabilityOfWrites("true");
156 //don't overwrite a keyspace we already have
157 jsonKeyspace.setKeyspaceName(keyspaceToCreate);
158 jsonKeyspace.setReplicationInfo(replicationInfo);
159 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
161 data.createKeySpace("1", "1", "1", null, authorization, appName, jsonKeyspace, keyspaceToCreate);
162 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
163 assertEquals(200, response.getStatus());
164 Map<String, String> respMap = (Map<String, String>) response.getEntity();
165 assertEquals(ResultType.SUCCESS, respMap.get("status"));
167 response = data.dropKeySpace("1", "1", "1", null, authorization, appName, keyspaceToCreate);
168 assertEquals(200, response.getStatus());
169 respMap = (Map<String, String>) response.getEntity();
170 assertEquals(ResultType.SUCCESS, respMap.get("status"));
172 //unset to not mess up any further tests
173 MusicUtil.setKeyspaceActive(false);
177 public void test3_createTable() throws Exception {
178 System.out.println("Testing create table");
179 JsonTable jsonTable = new JsonTable();
180 Map<String, String> consistencyInfo = new HashMap<>();
181 Map<String, String> fields = new HashMap<>();
182 fields.put("uuid", "text");
183 fields.put("emp_name", "text");
184 fields.put("emp_salary", "varint");
185 fields.put("PRIMARY KEY", "(emp_name)");
186 consistencyInfo.put("type", "eventual");
187 jsonTable.setConsistencyInfo(consistencyInfo);
188 jsonTable.setKeyspaceName(keyspaceName);
189 jsonTable.setPrimaryKey("emp_name");
190 jsonTable.setTableName(tableName);
191 jsonTable.setFields(fields);
192 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
193 authorization, jsonTable, keyspaceName, tableName);
194 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
195 assertEquals(200, response.getStatus());
199 public void test3_createTableNoBody() throws Exception {
200 System.out.println("Testing create table w/o body");
202 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
203 authorization, null, keyspaceName, tableName);
204 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
205 assertEquals(400, response.getStatus());
209 public void test3_createTableNoName() throws Exception {
210 System.out.println("Testing create table without name");
211 JsonTable jsonTable = new JsonTable();
212 Map<String, String> consistencyInfo = new HashMap<>();
213 Map<String, String> fields = new HashMap<>();
214 fields.put("uuid", "text");
215 fields.put("emp_name", "text");
216 fields.put("emp_salary", "varint");
217 fields.put("PRIMARY KEY", "(emp_name)");
218 consistencyInfo.put("type", "eventual");
219 jsonTable.setConsistencyInfo(consistencyInfo);
220 jsonTable.setKeyspaceName(keyspaceName);
221 jsonTable.setPrimaryKey("emp_name");
222 jsonTable.setTableName("");
223 jsonTable.setFields(fields);
224 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
225 authorization, jsonTable, keyspaceName, "");
226 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
227 assertEquals(400, response.getStatus());
231 public void test3_createTableNoFields() throws Exception {
232 System.out.println("Testing create table without fields");
233 JsonTable jsonTable = new JsonTable();
234 Map<String, String> consistencyInfo = new HashMap<>();
235 consistencyInfo.put("type", "eventual");
236 jsonTable.setConsistencyInfo(consistencyInfo);
237 jsonTable.setKeyspaceName(keyspaceName);
238 jsonTable.setPrimaryKey("emp_name");
239 jsonTable.setTableName("");
240 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
241 authorization, jsonTable, keyspaceName, "");
242 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
243 assertEquals(400, response.getStatus());
248 public void test3_createTableClusterOrderBad() throws Exception {
249 System.out.println("Testing create table bad clustering");
250 JsonTable jsonTable = new JsonTable();
251 Map<String, String> consistencyInfo = new HashMap<>();
252 Map<String, String> fields = new HashMap<>();
253 fields.put("uuid", "text");
254 fields.put("emp_name", "text");
255 fields.put("emp_salary", "varint");
256 fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
257 consistencyInfo.put("type", "eventual");
258 jsonTable.setConsistencyInfo(consistencyInfo);
259 jsonTable.setKeyspaceName(keyspaceName);
260 jsonTable.setPrimaryKey("emp_name,emp_salary");
261 jsonTable.setClusteringOrder("ASC");
262 jsonTable.setTableName(tableName);
263 jsonTable.setFields(fields);
264 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
265 authorization, jsonTable, keyspaceName, tableName);
266 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
267 assertEquals(400, response.getStatus());
271 public void test3_createTable_withPropertiesNotNull() throws Exception {
272 System.out.println("Testing create table with properties");
273 JsonTable jsonTable = new JsonTable();
274 Map<String, String> consistencyInfo = new HashMap<>();
275 Map<String, String> fields = new HashMap<>();
276 fields.put("uuid", "text");
277 fields.put("emp_name", "text");
278 fields.put("emp_salary", "varint");
279 fields.put("PRIMARY KEY", "(emp_name)");
280 consistencyInfo.put("type", "eventual");
281 Map<String, Object> properties = new HashMap<>();
282 properties.put("comment", "Testing prperties not null");
283 jsonTable.setConsistencyInfo(consistencyInfo);
284 jsonTable.setKeyspaceName(keyspaceName);
285 jsonTable.setPrimaryKey("emp_name");
286 String tableName_prop = tableName + "_Prop";
287 jsonTable.setTableName(tableName_prop);
288 jsonTable.setFields(fields);
289 jsonTable.setProperties(properties);
291 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
292 authorization, jsonTable, keyspaceName, tableName_prop);
293 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
294 assertEquals(200, response.getStatus());
298 public void test3_createTable_duplicateTable() throws Exception {
299 System.out.println("Testing creating duplicate tables");
300 JsonTable jsonTable = new JsonTable();
301 Map<String, String> consistencyInfo = new HashMap<>();
302 Map<String, String> fields = new HashMap<>();
303 fields.put("uuid", "text");
304 fields.put("emp_name", "text");
305 fields.put("emp_salary", "varint");
306 fields.put("PRIMARY KEY", "(emp_name)");
307 consistencyInfo.put("type", "eventual");
308 jsonTable.setConsistencyInfo(consistencyInfo);
309 jsonTable.setKeyspaceName(keyspaceName);
310 jsonTable.setPrimaryKey("emp_name");
311 String tableNameDup = tableName + "x";
312 jsonTable.setTableName(tableNameDup);
313 jsonTable.setFields(fields);
314 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
315 Response response1 = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
316 authorization, jsonTable, keyspaceName, tableNameDup);
318 Response response2 = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
319 authorization, jsonTable, keyspaceName, tableNameDup);
320 System.out.println("Status: " + response2.getStatus() + ". Entity " + response2.getEntity());
322 assertEquals(400, response2.getStatus());
323 Map<String, String> respMap = (Map<String, String>) response2.getEntity();
324 assertEquals(ResultType.FAILURE, respMap.get("status"));
325 assertEquals("AlreadyExistsException: Table " + keyspaceName + "." + tableNameDup + " already exists", respMap.get("error"));
329 // Improper parenthesis in key field
331 public void test3_createTable_badParanthesis() throws Exception {
332 System.out.println("Testing malformed create table request");
333 String tableNameC = "testTable0";
334 JsonTable jsonTable = new JsonTable();
335 Map<String, String> consistencyInfo = new HashMap<>();
336 Map<String, String> fields = new HashMap<>();
337 fields.put("uuid", "text");
338 fields.put("emp_name", "text");
339 fields.put("emp_salary", "varint");
340 fields.put("PRIMARY KEY", "(emp_name),emp_id)");
341 fields.put("emp_id", "varint");
342 consistencyInfo.put("type", "eventual");
343 jsonTable.setConsistencyInfo(consistencyInfo);
344 jsonTable.setKeyspaceName(keyspaceName);
345 jsonTable.setPrimaryKey("emp_name");
346 jsonTable.setTableName(tableNameC);
347 jsonTable.setClusteringOrder("emp_id Desc");
348 jsonTable.setFields(fields);
349 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
350 authorization, jsonTable, keyspaceName, tableNameC);
351 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
353 assertEquals(400, response.getStatus());
357 // good clustering key
359 public void test3_createTable_1_clusterKey_good() throws Exception {
360 System.out.println("Testing create w/ clusterKey");
362 String tableNameC = "testTableC1";
363 JsonTable jsonTable = new JsonTable();
364 Map<String, String> consistencyInfo = new HashMap<>();
365 Map<String, String> fields = new HashMap<>();
366 fields.put("uuid", "text");
367 fields.put("emp_name", "text");
368 fields.put("emp_salary", "varint");
369 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
370 consistencyInfo.put("type", "eventual");
371 jsonTable.setConsistencyInfo(consistencyInfo);
372 jsonTable.setKeyspaceName(keyspaceName);
373 // jsonTable.setPrimaryKey("emp_name");
374 jsonTable.setTableName(tableNameC);
375 jsonTable.setClusteringOrder("emp_salary ASC");
376 jsonTable.setFields(fields);
377 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
378 authorization, jsonTable, keyspaceName, tableNameC);
379 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
381 assertEquals(200, response.getStatus());
384 // bad partition key=clustering key
386 public void test3_createTable_2_clusterKey_bad() throws Exception {
387 System.out.println("Testing create w/ bad clusterKey");
388 String tableNameC = "testTableC2";
389 JsonTable jsonTable = new JsonTable();
390 Map<String, String> consistencyInfo = new HashMap<>();
391 Map<String, String> fields = new HashMap<>();
392 fields.put("uuid", "text");
393 fields.put("emp_name", "text");
394 fields.put("emp_salary", "varint");
395 fields.put("PRIMARY KEY", "((emp_name),emp_name)");
396 consistencyInfo.put("type", "eventual");
397 jsonTable.setConsistencyInfo(consistencyInfo);
398 jsonTable.setKeyspaceName(keyspaceName);
399 jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
400 jsonTable.setTableName(tableNameC);
401 jsonTable.setClusteringOrder("emp_salary ASC");
402 jsonTable.setFields(fields);
403 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
404 authorization, jsonTable, keyspaceName, tableNameC);
405 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
407 assertEquals(400, response.getStatus());
410 // good composite partition key,clustering key
412 public void test3_createTable_3_pfartition_clusterKey_good() throws Exception {
413 System.out.println("Testing create w/ composite partition key, clusterKey");
415 String tableNameC = "testTableC3";
416 JsonTable jsonTable = new JsonTable();
417 Map<String, String> consistencyInfo = new HashMap<>();
418 Map<String, String> fields = new HashMap<>();
419 fields.put("uuid", "text");
420 fields.put("emp_name", "text");
421 fields.put("emp_id", "varint");
422 fields.put("emp_salary", "varint");
423 fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
424 consistencyInfo.put("type", "eventual");
425 jsonTable.setConsistencyInfo(consistencyInfo);
426 jsonTable.setKeyspaceName(keyspaceName);
427 jsonTable.setPrimaryKey("emp_name");
428 jsonTable.setTableName(tableNameC);
429 jsonTable.setClusteringOrder("emp_salary ASC");
430 jsonTable.setFields(fields);
431 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
432 authorization, jsonTable, keyspaceName, tableNameC);
433 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
435 assertEquals(200, response.getStatus());
438 // bad - wrong cols in order by of composite partition key,clustering key
440 public void test3_createTable_5_clusteringOrder_bad() throws Exception {
441 System.out.println("Testing create table bad request with clustering & composite keys");
442 String tableNameC = "testTableC5";
443 JsonTable jsonTable = new JsonTable();
444 Map<String, String> consistencyInfo = new HashMap<>();
445 Map<String, String> fields = new HashMap<>();
446 fields.put("uuid", "text");
447 fields.put("emp_name", "text");
448 fields.put("emp_id", "varint");
449 fields.put("emp_salary", "varint");
450 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
451 consistencyInfo.put("type", "eventual");
452 jsonTable.setConsistencyInfo(consistencyInfo);
453 jsonTable.setKeyspaceName(keyspaceName);
454 jsonTable.setPrimaryKey("emp_name");
455 jsonTable.setTableName(tableNameC);
456 jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
457 jsonTable.setFields(fields);
458 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
459 authorization, jsonTable, keyspaceName, tableNameC);
460 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
462 assertEquals(400, response.getStatus());
466 // good clustering key, need to pass queryparameter
468 public void test3_createTableIndex_1() throws Exception {
469 System.out.println("Testing index in create table");
470 String tableNameC = "testTableCinx";
471 JsonTable jsonTable = new JsonTable();
472 Map<String, String> consistencyInfo = new HashMap<>();
473 Map<String, String> fields = new HashMap<>();
474 fields.put("uuid", "text");
475 fields.put("emp_name", "text");
476 fields.put("emp_salary", "varint");
477 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
478 consistencyInfo.put("type", "eventual");
479 jsonTable.setConsistencyInfo(consistencyInfo);
480 jsonTable.setKeyspaceName(keyspaceName);
481 jsonTable.setTableName(tableNameC);
482 jsonTable.setClusteringOrder("emp_salary ASC");
483 jsonTable.setFields(fields);
484 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
485 authorization, jsonTable, keyspaceName, tableNameC);
486 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
487 // info.setQueryParameters("index_name=inx_uuid");
488 Map<String, String> queryParametersMap = new HashMap<String, String>();
490 queryParametersMap.put("index_name", "inxuuid");
491 Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedHashMap<String, String>(queryParametersMap));
492 response = data.createIndex("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
493 keyspaceName, tableNameC, "uuid", info);
494 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
496 assertEquals(200, response.getStatus());
499 // create index without table name
501 public void test3_createTableIndexNoName() throws Exception {
502 System.out.println("Testing index in create table w/o tablename");
503 String tableNameC = "testTableCinx";
504 JsonTable jsonTable = new JsonTable();
505 Map<String, String> consistencyInfo = new HashMap<>();
506 Map<String, String> fields = new HashMap<>();
507 fields.put("uuid", "text");
508 fields.put("emp_name", "text");
509 fields.put("emp_salary", "varint");
510 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
511 consistencyInfo.put("type", "eventual");
512 jsonTable.setConsistencyInfo(consistencyInfo);
513 jsonTable.setKeyspaceName(keyspaceName);
514 jsonTable.setTableName(tableNameC);
515 jsonTable.setClusteringOrder("emp_salary ASC");
516 jsonTable.setFields(fields);
517 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
518 authorization, jsonTable, keyspaceName, tableNameC);
519 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
520 // info.setQueryParameters("index_name=inx_uuid");
521 Map<String, String> queryParametersMap = new HashMap<String, String>();
523 queryParametersMap.put("index_name", "inxuuid");
524 response = data.createIndex("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization, "",
526 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
528 assertEquals(400, response.getStatus());
532 public void test4_insertIntoTable() throws Exception {
533 System.out.println("Testing insert into table");
535 JsonInsert jsonInsert = new JsonInsert();
536 Map<String, String> consistencyInfo = new HashMap<>();
537 Map<String, Object> values = new HashMap<>();
538 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
539 values.put("emp_name", "testname");
540 values.put("emp_salary", 500);
541 consistencyInfo.put("type", "eventual");
542 jsonInsert.setConsistencyInfo(consistencyInfo);
543 jsonInsert.setKeyspaceName(keyspaceName);
544 jsonInsert.setTableName(tableName);
545 jsonInsert.setValues(values);
546 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
547 authorization, jsonInsert, keyspaceName, tableName);
548 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
550 assertEquals(200, response.getStatus());
554 public void test4_insertIntoTableNoBody() throws Exception {
555 System.out.println("Testing insert into table w/o body");
557 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
558 authorization, null, keyspaceName, tableName);
559 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
561 assertEquals(400, response.getStatus());
565 public void test4_insertIntoTableNoaValues() throws Exception {
566 System.out.println("Testing insert into table");
568 JsonInsert jsonInsert = new JsonInsert();
569 Map<String, String> consistencyInfo = new HashMap<>();
570 consistencyInfo.put("type", "eventual");
571 jsonInsert.setConsistencyInfo(consistencyInfo);
572 jsonInsert.setKeyspaceName(keyspaceName);
573 jsonInsert.setTableName(tableName);
575 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
576 authorization, jsonInsert, keyspaceName, tableName);
577 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
579 assertEquals(400, response.getStatus());
583 public void test4_insertIntoTableNoValues() throws Exception {
584 System.out.println("Testing insert into table");
586 JsonInsert jsonInsert = new JsonInsert();
587 Map<String, String> consistencyInfo = new HashMap<>();
588 consistencyInfo.put("type", "eventual");
589 jsonInsert.setConsistencyInfo(consistencyInfo);
590 jsonInsert.setKeyspaceName(keyspaceName);
591 jsonInsert.setTableName(tableName);
593 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
594 authorization, jsonInsert, keyspaceName, tableName);
595 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
597 assertEquals(400, response.getStatus());
601 public void test4_insertIntoTableCriticalNoLockID() throws Exception {
602 System.out.println("Testing critical insert into table without lockid");
604 JsonInsert jsonInsert = new JsonInsert();
605 Map<String, String> consistencyInfo = new HashMap<>();
606 Map<String, Object> values = new HashMap<>();
607 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
608 values.put("emp_name", "testname");
609 values.put("emp_salary", 500);
610 consistencyInfo.put("type", "critical");
611 jsonInsert.setConsistencyInfo(consistencyInfo);
612 jsonInsert.setKeyspaceName(keyspaceName);
613 jsonInsert.setTableName(tableName);
614 jsonInsert.setValues(values);
615 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
616 appName, authorization, jsonInsert, keyspaceName, tableName);
617 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
619 assertEquals(400, response.getStatus());
623 public void test4_insertIntoTableAtomic() throws Exception {
624 System.out.println("Testing atomic insert into table without lockid");
626 JsonInsert jsonInsert = new JsonInsert();
627 Map<String, String> consistencyInfo = new HashMap<>();
628 Map<String, Object> values = new HashMap<>();
629 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
630 values.put("emp_name", "testname");
631 values.put("emp_salary", 500);
632 consistencyInfo.put("type", "atomic");
633 jsonInsert.setConsistencyInfo(consistencyInfo);
634 jsonInsert.setKeyspaceName(keyspaceName);
635 jsonInsert.setTableName(tableName);
636 jsonInsert.setValues(values);
637 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
638 appName, authorization, jsonInsert, keyspaceName, tableName);
639 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
641 assertEquals(200, response.getStatus());
645 public void test4_insertIntoTableNoName() throws Exception {
646 System.out.println("Testing insert into table w/o table name");
648 JsonInsert jsonInsert = new JsonInsert();
649 Map<String, String> consistencyInfo = new HashMap<>();
650 Map<String, Object> values = new HashMap<>();
651 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
652 values.put("emp_name", "testname");
653 values.put("emp_salary", 500);
654 consistencyInfo.put("type", "eventual");
655 jsonInsert.setConsistencyInfo(consistencyInfo);
656 jsonInsert.setKeyspaceName(keyspaceName);
657 jsonInsert.setTableName(tableName);
658 jsonInsert.setValues(values);
659 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
660 appName, authorization, jsonInsert, "", "");
661 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
663 assertEquals(400, response.getStatus());
667 public void test4_insertIntoTable2() throws Exception {
668 System.out.println("Testing insert into table #2");
670 JsonInsert jsonInsert = new JsonInsert();
671 Map<String, String> consistencyInfo = new HashMap<>();
672 Map<String, Object> values = new HashMap<>();
673 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
674 values.put("emp_name", "test1");
675 values.put("emp_salary", 1500);
676 consistencyInfo.put("type", "eventual");
677 jsonInsert.setConsistencyInfo(consistencyInfo);
678 jsonInsert.setKeyspaceName(keyspaceName);
679 jsonInsert.setTableName(tableName);
680 jsonInsert.setValues(values);
681 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
682 authorization, jsonInsert, keyspaceName, tableName);
683 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
685 assertEquals(200, response.getStatus());
690 public void test4_insertIntoTable4() throws Exception {
691 System.out.println("Testing insert into wrong table");
693 JsonInsert jsonInsert = new JsonInsert();
694 Map<String, String> consistencyInfo = new HashMap<>();
695 Map<String, Object> values = new HashMap<>();
696 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
697 values.put("emp_name", "test1");
698 values.put("emp_salary", 1500);
699 consistencyInfo.put("type", "eventual");
700 jsonInsert.setConsistencyInfo(consistencyInfo);
701 jsonInsert.setKeyspaceName(keyspaceName);
702 jsonInsert.setTableName(tableName);
703 jsonInsert.setValues(values);
704 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
705 authorization, jsonInsert, keyspaceName, "wrong");
706 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
708 assertEquals(400, response.getStatus());
712 public void test4_insertBlobIntoTable() throws Exception {
713 System.out.println("Testing insert a blob into table");
715 JsonInsert jsonInsert = new JsonInsert();
716 Map<String, String> consistencyInfo = new HashMap<>();
717 Map<String, Object> values = new HashMap<>();
718 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
719 values.put("emp_name", "testname");
720 values.put("emp_salary", 500);
721 values.put("binary", "somestuffhere");
722 consistencyInfo.put("type", "eventual");
723 jsonInsert.setConsistencyInfo(consistencyInfo);
724 jsonInsert.setKeyspaceName(keyspaceName);
725 jsonInsert.setTableName(tableName);
726 jsonInsert.setValues(values);
727 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
728 authorization, jsonInsert, keyspaceName, tableName);
729 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
731 assertEquals(200, response.getStatus());
735 public void test5_updateTable() throws Exception {
736 System.out.println("Testing update table");
739 JsonUpdate jsonUpdate = new JsonUpdate();
740 Map<String, String> consistencyInfo = new HashMap<>();
741 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
742 Map<String, Object> values = new HashMap<>();
743 row.add("emp_name", "testname");
744 values.put("emp_salary", 2500);
745 consistencyInfo.put("type", "atomic");
746 jsonUpdate.setConsistencyInfo(consistencyInfo);
747 jsonUpdate.setKeyspaceName(keyspaceName);
748 jsonUpdate.setTableName(tableName);
749 jsonUpdate.setValues(values);
750 Mockito.when(info.getQueryParameters()).thenReturn(row);
751 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
752 authorization, jsonUpdate, keyspaceName, tableName, info);
754 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
756 assertEquals(200, response.getStatus());
760 public void test5_updateTableNoBody() throws Exception {
761 System.out.println("Testing update table no body");
764 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
765 authorization, null, keyspaceName, tableName, info);
767 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
769 assertEquals(400, response.getStatus());
773 public void test5_updateTable_tableDNE() throws Exception {
774 System.out.println("Testing update table that does not exist");
777 JsonUpdate jsonUpdate = new JsonUpdate();
778 Map<String, String> consistencyInfo = new HashMap<>();
779 Map<String, Object> values = new HashMap<>();
780 values.put("emp_salary", 2500);
781 consistencyInfo.put("type", "atomic");
782 jsonUpdate.setConsistencyInfo(consistencyInfo);
783 jsonUpdate.setKeyspaceName(keyspaceName);
784 jsonUpdate.setTableName("wrong_"+tableName);
785 jsonUpdate.setValues(values);
786 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
787 authorization, jsonUpdate, keyspaceName, "wrong_"+ tableName, info);
789 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
791 assertEquals(400, response.getStatus());
795 public void test5_updateTableNoName() throws Exception {
796 System.out.println("Testing update table without tablename");
799 JsonUpdate jsonUpdate = new JsonUpdate();
800 Map<String, String> consistencyInfo = new HashMap<>();
801 Map<String, Object> values = new HashMap<>();
802 values.put("emp_salary", 2500);
803 consistencyInfo.put("type", "atomic");
804 jsonUpdate.setConsistencyInfo(consistencyInfo);
805 jsonUpdate.setKeyspaceName(keyspaceName);
806 jsonUpdate.setTableName(tableName);
807 jsonUpdate.setValues(values);
808 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
809 authorization, jsonUpdate, "", "", info);
811 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
813 assertEquals(400, response.getStatus());
816 // need mock code to create error for MusicCore methods
818 public void test5_updateTableAuthE() throws Exception {
819 System.out.println("Testing update table #2");
821 // MockitoAnnotations.initMocks(this);
822 JsonUpdate jsonUpdate = new JsonUpdate();
823 Map<String, String> consistencyInfo = new HashMap<>();
824 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
825 Map<String, Object> values = new HashMap<>();
826 row.add("emp_name", "testname");
827 values.put("emp_salary", 2500);
828 consistencyInfo.put("type", "atomic");
829 jsonUpdate.setConsistencyInfo(consistencyInfo);
830 jsonUpdate.setKeyspaceName(keyspaceName);
831 jsonUpdate.setTableName(tableName);
832 jsonUpdate.setValues(values);
833 // add ttl & timestamp
834 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
835 Mockito.when(info.getQueryParameters()).thenReturn(row);
836 // Map<String, Object> m1= new HashMap<>() ;
837 // Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
838 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
839 authorization, jsonUpdate, keyspaceName, tableName, info);
840 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
842 assertEquals(200, response.getStatus());
846 public void test6_critical_selectAtomic() throws Exception {
847 System.out.println("Testing critical select atomic");
848 createAndInsertIntoTable();
849 JsonInsert jsonInsert = new JsonInsert();
850 Map<String, String> consistencyInfo = new HashMap<>();
851 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
852 row.add("emp_name", "testname");
853 consistencyInfo.put("type", "atomic");
854 jsonInsert.setConsistencyInfo(consistencyInfo);
855 Mockito.when(info.getQueryParameters()).thenReturn(row);
856 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
857 appName, authorization, jsonInsert, keyspaceName, tableName,info);
858 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
859 HashMap<String, Object> result = map.get("result");
860 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
862 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
863 assertEquals("testname", row0.get("emp_name"));
864 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
869 public void test6_critical_select() throws Exception {
870 System.out.println("Testing critical select w/o body");
871 createAndInsertIntoTable();
872 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
873 row.add("emp_name", "testname");
874 Mockito.when(info.getQueryParameters()).thenReturn(row);
875 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
876 appName, authorization, null, keyspaceName, tableName,info);
877 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
878 HashMap<String, Object> result = map.get("result");
879 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
881 assertEquals(400, response.getStatus());
884 // Added during merge?
886 public void test6_critical_selectCritical_nolockid() throws Exception {
887 System.out.println("Testing critical select critical w/o lockid");
888 createAndInsertIntoTable();
889 JsonInsert jsonInsert = new JsonInsert();
890 Map<String, String> consistencyInfo = new HashMap<>();
891 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
892 row.add("emp_name", "testname");
893 consistencyInfo.put("type", "critical");
894 jsonInsert.setConsistencyInfo(consistencyInfo);
895 Mockito.when(info.getQueryParameters()).thenReturn(row);
896 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
897 appName, authorization, jsonInsert, keyspaceName, tableName,info);
898 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
899 HashMap<String, Object> result = map.get("result");
900 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
902 assertEquals(400, response.getStatus());
906 public void test6_critical_select_nulltable() throws Exception {
907 System.out.println("Testing critical select w/ null tablename");
908 createAndInsertIntoTable();
909 JsonInsert jsonInsert = new JsonInsert();
910 Map<String, String> consistencyInfo = new HashMap<>();
911 consistencyInfo.put("type", "atomic");
912 jsonInsert.setConsistencyInfo(consistencyInfo);
913 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
914 appName, authorization, jsonInsert, keyspaceName, null,info);
915 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
917 assertEquals(400, response.getStatus());
921 public void test6_select() throws Exception {
922 System.out.println("Testing select");
923 createAndInsertIntoTable();
924 JsonSelect jsonSelect = new JsonSelect();
925 Map<String, String> consistencyInfo = new HashMap<>();
926 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
927 row.add("emp_name", "testname");
928 consistencyInfo.put("type", "atomic");
929 jsonSelect.setConsistencyInfo(consistencyInfo);
930 Mockito.when(info.getQueryParameters()).thenReturn(row);
931 Response response = data.selectWithCritical("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
932 null,keyspaceName, tableName, info);
933 HashMap<String, HashMap<String, Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
934 HashMap<String, Object> result = map.get("result");
935 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
937 Map<String, String> row0 = (Map<String, String>) result.get("row 0");
938 assertEquals("testname", row0.get("emp_name"));
939 assertEquals(BigInteger.valueOf(500), row0.get("emp_salary"));
943 public void test6_select_nullTablename() throws Exception {
944 System.out.println("Testing select w/ null tablename");
945 createAndInsertIntoTable();
946 JsonSelect jsonSelect = new JsonSelect();
947 Map<String, String> consistencyInfo = new HashMap<>();
948 consistencyInfo.put("type", "atomic");
949 jsonSelect.setConsistencyInfo(consistencyInfo);
950 Response response = data.selectWithCritical("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
951 appName, wrongAuthorization,null, keyspaceName, null, info);
952 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
954 assertEquals(400, response.getStatus());
958 public void test6_deleteFromTable() throws Exception {
959 System.out.println("Testing delete from table");
960 createAndInsertIntoTable();
961 JsonDelete jsonDelete = new JsonDelete();
962 Map<String, String> consistencyInfo = new HashMap<>();
963 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
964 row.add("emp_name", "test1");
965 consistencyInfo.put("type", "atomic");
966 jsonDelete.setConsistencyInfo(consistencyInfo);
967 Mockito.when(info.getQueryParameters()).thenReturn(row);
968 Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
969 authorization, jsonDelete, keyspaceName, tableName, info);
970 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
971 assertEquals(200, response.getStatus());
975 public void test6_deleteFromTable_missingTablename() throws Exception {
976 System.out.println("Testing delete from table w/ null tablename");
977 createAndInsertIntoTable();
978 JsonDelete jsonDelete = new JsonDelete();
979 Map<String, String> consistencyInfo = new HashMap<>();
980 consistencyInfo.put("type", "atomic");
981 jsonDelete.setConsistencyInfo(consistencyInfo);
982 Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
983 wrongAuthorization, jsonDelete, keyspaceName, null, info);
984 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
985 assertEquals(400, response.getStatus());
991 public void test6_deleteFromTable1() throws Exception {
992 System.out.println("Testing delete from table missing delete object");
993 createAndInsertIntoTable();
995 JsonDelete jsonDelete = new JsonDelete();
996 Map<String, String> consistencyInfo = new HashMap<>();
997 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
998 consistencyInfo.put("type", "atomic");
999 jsonDelete.setConsistencyInfo(consistencyInfo);
1000 Mockito.when(info.getQueryParameters()).thenReturn(row);
1001 Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1002 authorization, jsonDelete, keyspaceName, tableName, info);
1003 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1005 assertEquals(400, response.getStatus());
1010 public void test6_deleteFromTable2() throws Exception {
1011 System.out.println("Testing delete from table missing delete object");
1012 createAndInsertIntoTable();
1013 JsonDelete jsonDelete = new JsonDelete();
1014 Map<String, String> consistencyInfo = new HashMap<>();
1015 consistencyInfo.put("type", "atomic");
1016 jsonDelete.setConsistencyInfo(consistencyInfo);
1017 Response response = data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1018 authorization, null, keyspaceName, tableName, info);
1019 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1021 assertEquals(400, response.getStatus());
1025 public void test7_dropTable() throws Exception {
1026 System.out.println("Testing drop table");
1028 JsonTable jsonTable = new JsonTable();
1029 Map<String, String> consistencyInfo = new HashMap<>();
1030 consistencyInfo.put("type", "atomic");
1031 jsonTable.setConsistencyInfo(consistencyInfo);
1032 Response response = data.dropTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1033 authorization, keyspaceName, tableName);
1034 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1036 assertEquals(200, response.getStatus());
1040 public void test7_dropTable_nullTablename() throws Exception {
1041 System.out.println("Testing drop table w/ null tablename");
1043 JsonTable jsonTable = new JsonTable();
1044 Map<String, String> consistencyInfo = new HashMap<>();
1045 consistencyInfo.put("type", "atomic");
1046 jsonTable.setConsistencyInfo(consistencyInfo);
1047 Response response = data.dropTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1048 authorization, keyspaceName, null);
1049 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1051 assertEquals(400, response.getStatus());
1056 public void test8_deleteKeyspace() throws Exception {
1057 System.out.println("Testing drop keyspace");
1059 JsonKeySpace jsonKeyspace = new JsonKeySpace();
1060 Map<String, String> consistencyInfo = new HashMap<>();
1061 Map<String, Object> replicationInfo = new HashMap<>();
1062 consistencyInfo.put("type", "eventual");
1063 replicationInfo.put("class", "SimpleStrategy");
1064 replicationInfo.put("replication_factor", 1);
1065 jsonKeyspace.setConsistencyInfo(consistencyInfo);
1066 jsonKeyspace.setDurabilityOfWrites("true");
1067 jsonKeyspace.setKeyspaceName("TestApp1");
1068 jsonKeyspace.setReplicationInfo(replicationInfo);
1069 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,
1070 appName, keyspaceName);
1071 System.out.println("Status: " + response.getStatus() + ". Entity " + response.getEntity());
1073 assertEquals(400, response.getStatus());
1076 private static void createKeyspace() throws Exception {
1077 // shouldn't really be doing this here, but create keyspace is currently turned off
1078 PreparedQueryObject query = new PreparedQueryObject();
1079 query.appendQueryString(CassandraCQL.createKeySpace);
1080 MusicCore.eventualPut(query);
1082 boolean isAAF = false;
1083 String hashedpwd = BCrypt.hashpw(password, BCrypt.gensalt());
1084 query = new PreparedQueryObject();
1085 query.appendQueryString("INSERT into admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
1086 + "password, username, is_aaf) values (?,?,?,?,?,?,?)");
1087 query.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
1088 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), keyspaceName));
1089 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
1090 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
1091 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), hashedpwd));
1092 query.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
1093 query.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
1094 MusicCore.eventualPut(query);
1097 private void clearAllTablesFromKeyspace() throws MusicServiceException {
1098 ArrayList<String> tableNames = new ArrayList<>();
1099 PreparedQueryObject query = new PreparedQueryObject();
1100 query.appendQueryString(
1101 "SELECT table_name FROM system_schema.tables WHERE keyspace_name = '" + keyspaceName + "';");
1102 ResultSet rs = MusicCore.get(query);
1103 for (Row row : rs) {
1104 tableNames.add(row.getString("table_name"));
1106 for (String table : tableNames) {
1107 query = new PreparedQueryObject();
1108 query.appendQueryString("DROP TABLE " + keyspaceName + "." + table);
1109 MusicCore.eventualPut(query);
1114 * Create a table {@link tableName} in {@link keyspaceName}
1118 private void createTable() throws Exception {
1119 JsonTable jsonTable = new JsonTable();
1120 Map<String, String> consistencyInfo = new HashMap<>();
1121 Map<String, String> fields = new HashMap<>();
1122 fields.put("uuid", "text");
1123 fields.put("emp_name", "text");
1124 fields.put("emp_salary", "varint");
1125 fields.put("binary", "blob");
1126 fields.put("PRIMARY KEY", "(emp_name)");
1127 consistencyInfo.put("type", "eventual");
1128 jsonTable.setConsistencyInfo(consistencyInfo);
1129 jsonTable.setKeyspaceName(keyspaceName);
1130 jsonTable.setPrimaryKey("emp_name");
1131 jsonTable.setTableName(tableName);
1132 jsonTable.setFields(fields);
1133 // Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1134 Response response = data.createTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1135 authorization, jsonTable, keyspaceName, tableName);
1139 * Create table {@link createTable} and insert into said table
1143 private void createAndInsertIntoTable() throws Exception {
1146 JsonInsert jsonInsert = new JsonInsert();
1147 Map<String, String> consistencyInfo = new HashMap<>();
1148 Map<String, Object> values = new HashMap<>();
1149 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1150 values.put("emp_name", "testname");
1151 values.put("emp_salary", 500);
1152 values.put("binary", "binarydatahere");
1153 consistencyInfo.put("type", "eventual");
1154 jsonInsert.setConsistencyInfo(consistencyInfo);
1155 jsonInsert.setKeyspaceName(keyspaceName);
1156 jsonInsert.setTableName(tableName);
1157 jsonInsert.setValues(values);
1158 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1159 authorization, jsonInsert, keyspaceName, tableName);