2 * ============LICENSE_START========================================== org.onap.music
3 * =================================================================== Copyright (c) 2017 AT&T
4 * Intellectual Property ===================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
6 * in compliance with the License. You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software distributed under the License
11 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12 * or implied. See the License for the specific language governing permissions and limitations under
15 * ============LICENSE_END=============================================
16 * ====================================================================
19 package org.onap.music.unittests;
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertFalse;
23 import static org.junit.Assert.assertNotEquals;
24 import static org.junit.Assert.assertTrue;
26 import java.util.HashMap;
27 import java.util.List;
29 import java.util.UUID;
30 import javax.servlet.http.HttpServletResponse;
31 import javax.ws.rs.core.MultivaluedMap;
32 import javax.ws.rs.core.Response;
33 import javax.ws.rs.core.UriInfo;
34 import org.apache.curator.test.TestingServer;
35 import org.junit.AfterClass;
36 import org.junit.BeforeClass;
37 import org.junit.FixMethodOrder;
38 import org.junit.Ignore;
39 import org.junit.Test;
40 import org.junit.runner.RunWith;
41 import org.junit.runners.MethodSorters;
42 import org.mindrot.jbcrypt.BCrypt;
43 import org.mockito.Mock;
44 import org.mockito.Mockito;
45 import org.mockito.junit.MockitoJUnitRunner;
46 import org.onap.music.datastore.MusicDataStoreHandle;
47 import org.onap.music.datastore.PreparedQueryObject;
48 import org.onap.music.datastore.jsonobjects.JsonDelete;
49 import org.onap.music.datastore.jsonobjects.JsonInsert;
50 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
51 import org.onap.music.datastore.jsonobjects.JsonOnboard;
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.lockingservice.cassandra.CassaLockStore;
56 import org.onap.music.main.CachingUtil;
57 import org.onap.music.main.MusicCore;
58 import org.onap.music.main.MusicUtil;
59 import org.onap.music.main.ResultType;
60 import org.onap.music.rest.RestMusicAdminAPI;
61 import org.onap.music.rest.RestMusicDataAPI;
62 import org.onap.music.rest.RestMusicLocksAPI;
63 import com.datastax.driver.core.DataType;
64 import com.datastax.driver.core.ResultSet;
65 import com.datastax.driver.core.Row;
66 import com.sun.jersey.core.util.Base64;
67 import com.sun.jersey.core.util.MultivaluedMapImpl;
69 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
70 @RunWith(MockitoJUnitRunner.class)
71 public class TestRestMusicData {
73 RestMusicDataAPI data = new RestMusicDataAPI();
74 RestMusicAdminAPI admin = new RestMusicAdminAPI();
75 RestMusicLocksAPI lock = new RestMusicLocksAPI();
76 static PreparedQueryObject testObject;
77 static TestingServer zkServer;
80 HttpServletResponse http;
85 static String appName = "TestApp";
86 static String userId = "TestUser";
87 static String password = "TestPassword";
88 static String authData = userId+":"+password;
89 static String wrongAuthData = userId+":"+"pass";
90 static String authorization = new String(Base64.encode(authData.getBytes()));
91 static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
92 static boolean isAAF = false;
93 static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
94 static String keyspaceName = "testCassa";
95 static String tableName = "employees";
96 static String xLatestVersion = "X-latestVersion";
97 static String onboardUUID = null;
98 static String lockId = null;
99 static String lockName = "testCassa.employees.sample3";
102 public static void init() throws Exception {
104 MusicDataStoreHandle.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
105 MusicCore.mLockHandle = new CassaLockStore(MusicDataStoreHandle.mDstoreHandle);
106 } catch (Exception e) {
112 public static void tearDownAfterClass() throws Exception {
113 testObject = new PreparedQueryObject();
114 testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
115 MusicCore.eventualPut(testObject);
116 testObject = new PreparedQueryObject();
117 testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
118 MusicCore.eventualPut(testObject);
119 if(MusicDataStoreHandle.mDstoreHandle!=null)
120 MusicDataStoreHandle.mDstoreHandle.close();
126 public void Test1_createKeyspace() throws Exception {
127 testObject = new PreparedQueryObject();
128 testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = "
129 + "{'class' : 'SimpleStrategy' , "
130 + "'replication_factor': 1} AND DURABLE_WRITES = true");
131 MusicCore.eventualPut(testObject);
132 testObject = new PreparedQueryObject();
133 testObject.appendQueryString(
134 "CREATE TABLE admin.keyspace_master (" + " uuid uuid, keyspace_name text,"
135 + " application_name text, is_api boolean,"
136 + " password text, username text,"
137 + " is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
138 MusicCore.eventualPut(testObject);
140 testObject = new PreparedQueryObject();
141 testObject.appendQueryString(
142 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
143 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
144 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
145 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
146 MusicUtil.DEFAULTKEYSPACENAME));
147 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
148 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
149 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
150 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
151 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
152 MusicCore.eventualPut(testObject);
154 testObject = new PreparedQueryObject();
155 testObject.appendQueryString(
156 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
157 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
158 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
159 UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
160 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
161 MusicUtil.DEFAULTKEYSPACENAME));
162 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
163 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
164 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
165 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
166 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
167 MusicCore.eventualPut(testObject);
169 testObject = new PreparedQueryObject();
170 testObject.appendQueryString(
171 "select uuid from admin.keyspace_master where application_name = ? allow filtering");
172 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
173 ResultSet rs = MusicCore.get(testObject);
174 List<Row> rows = rs.all();
175 if (rows.size() > 0) {
176 System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
181 public void Test2_createKeyspace() throws Exception {
182 JsonKeySpace jsonKeyspace = new JsonKeySpace();
183 Map<String, String> consistencyInfo = new HashMap<>();
184 Map<String, Object> replicationInfo = new HashMap<>();
185 consistencyInfo.put("type", "eventual");
186 replicationInfo.put("class", "SimpleStrategy");
187 replicationInfo.put("replication_factor", 1);
188 jsonKeyspace.setConsistencyInfo(consistencyInfo);
189 jsonKeyspace.setDurabilityOfWrites("true");
190 jsonKeyspace.setKeyspaceName(keyspaceName);
191 jsonKeyspace.setReplicationInfo(replicationInfo);
192 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
193 Response response = data.createKeySpace("1", "1", "1", null,authorization, appName, jsonKeyspace, keyspaceName);
194 System.out.println("#######status is " + response.getStatus());
195 System.out.println("Entity" + response.getEntity());
196 assertEquals(400,response.getStatus());
200 public void Test2_createKeyspace0() throws Exception {
201 JsonKeySpace jsonKeyspace = new JsonKeySpace();
202 Map<String, String> consistencyInfo = new HashMap<>();
203 Map<String, Object> replicationInfo = new HashMap<>();
204 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
205 Response response = data.createKeySpace("1", "1", "1", null, authorization,appName, jsonKeyspace, keyspaceName);
206 System.out.println("#######status is " + response.getStatus());
207 System.out.println("Entity" + response.getEntity());
208 assertEquals(400,response.getStatus());
210 //MusicCore.autheticateUser
212 public void Test2_createKeyspace01() throws Exception {
213 JsonKeySpace jsonKeyspace = new JsonKeySpace();
214 Map<String, String> consistencyInfo = new HashMap<>();
215 Map<String, Object> replicationInfo = new HashMap<>();
216 String appName1 = "test";
217 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
218 Response response = data.createKeySpace("1", "1", "1", null,authorization, appName1, jsonKeyspace, keyspaceName);
219 System.out.println("#######status is " + response.getStatus());
220 System.out.println("Entity" + response.getEntity());
221 assertEquals(400,response.getStatus());
225 public void Test3_createKeyspace1() throws Exception {
226 JsonKeySpace jsonKeyspace = new JsonKeySpace();
227 Map<String, String> consistencyInfo = new HashMap<>();
228 Map<String, Object> replicationInfo = new HashMap<>();
229 consistencyInfo.put("type", "eventual");
230 replicationInfo.put("class", "SimpleStrategy");
231 replicationInfo.put("replication_factor", 1);
232 jsonKeyspace.setConsistencyInfo(consistencyInfo);
233 jsonKeyspace.setDurabilityOfWrites("true");
234 jsonKeyspace.setKeyspaceName("TestApp1");
235 jsonKeyspace.setReplicationInfo(replicationInfo);
236 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
237 Response response = data.createKeySpace("1", "1", "1", null,authorization, "TestApp1",
238 jsonKeyspace, keyspaceName);
239 System.out.println("#######status is " + response.getStatus());
240 System.out.println("Entity" + response.getEntity());
241 assertEquals(400,response.getStatus());
245 public void Test2_createKeyspaceEmptyAuth() throws Exception {
246 JsonKeySpace jsonKeyspace = new JsonKeySpace();
247 Map<String, String> consistencyInfo = new HashMap<>();
248 Map<String, Object> replicationInfo = new HashMap<>();
249 consistencyInfo.put("type", "eventual");
250 replicationInfo.put("class", "SimpleStrategy");
251 replicationInfo.put("replication_factor", 1);
252 jsonKeyspace.setConsistencyInfo(consistencyInfo);
253 jsonKeyspace.setDurabilityOfWrites("true");
254 jsonKeyspace.setKeyspaceName(keyspaceName);
255 jsonKeyspace.setReplicationInfo(replicationInfo);
256 //Map<String, Object> m1= new HashMap<>() ;
257 //Mockito.when(CachingUtil.verifyOnboarding("x","y","x")).thenReturn(m1);
258 //Mockito.when(CachingUtil.verifyOnboarding(appNamex,userId,password).thenReturn(m1));
259 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
260 String authDatax = ":"+password;
261 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
263 Response response = data.createKeySpace("1", "1", "1", null,authorizationx, appName, jsonKeyspace, keyspaceName);
264 System.out.println("#######status is " + response.getStatus());
265 System.out.println("Entity" + response.getEntity());
266 assertNotEquals(200,response.getStatus());
267 } catch (RuntimeException e ) {
268 System.out.println("#######status is runtime exception= " + e);
273 public void Test3_createTable() throws Exception {
274 JsonTable jsonTable = new JsonTable();
275 Map<String, String> consistencyInfo = new HashMap<>();
276 Map<String, String> fields = new HashMap<>();
277 fields.put("uuid", "text");
278 fields.put("emp_name", "text");
279 fields.put("emp_salary", "varint");
280 fields.put("PRIMARY KEY", "(emp_name)");
281 consistencyInfo.put("type", "eventual");
282 jsonTable.setConsistencyInfo(consistencyInfo);
283 jsonTable.setKeyspaceName(keyspaceName);
284 jsonTable.setPrimaryKey("emp_name");
285 jsonTable.setTableName(tableName);
286 jsonTable.setFields(fields);
287 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
288 Response response = data.createTable("1", "1", "1",
289 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
290 jsonTable, keyspaceName, tableName);
291 System.out.println("#######status is " + response.getStatus());
292 System.out.println("Entity" + response.getEntity());
293 //assertEquals(200, response.getStatus());
294 assertEquals(401, response.getStatus());
299 public void Test3_createTableClusterOrderBad() throws Exception {
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,emp_salary)");
307 consistencyInfo.put("type", "eventual");
308 jsonTable.setConsistencyInfo(consistencyInfo);
309 jsonTable.setKeyspaceName(keyspaceName);
310 jsonTable.setPrimaryKey("emp_name,emp_salary");
311 jsonTable.setClusteringOrder("ASC");
312 jsonTable.setTableName(tableName);
313 jsonTable.setFields(fields);
314 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
315 Response response = data.createTable("1", "1", "1",
316 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
317 jsonTable, keyspaceName, tableName);
318 System.out.println("#######status is " + response.getStatus());
319 System.out.println("Entity" + response.getEntity());
320 assertNotEquals(200, response.getStatus());
324 public void Test3_createTable_withPropertiesNotNull() throws Exception {
325 JsonTable jsonTable = new JsonTable();
326 Map<String, String> consistencyInfo = new HashMap<>();
327 Map<String, String> fields = new HashMap<>();
328 fields.put("uuid", "text");
329 fields.put("emp_name", "text");
330 fields.put("emp_salary", "varint");
331 fields.put("PRIMARY KEY", "(emp_name)");
332 consistencyInfo.put("type", "eventual");
333 Map<String, Object> properties = new HashMap<>();
334 properties.put("comment","Testing prperties not null");
335 jsonTable.setConsistencyInfo(consistencyInfo);
336 jsonTable.setKeyspaceName(keyspaceName);
337 jsonTable.setPrimaryKey("emp_name");
338 String tableName_prop=tableName+"_Prop";
339 jsonTable.setTableName(tableName_prop);
340 jsonTable.setFields(fields);
341 jsonTable.setProperties(properties);
343 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
344 Response response = data.createTable("1", "1", "1",
345 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
346 jsonTable, keyspaceName, tableName_prop);
347 System.out.println("#######status is " + response.getStatus());
348 System.out.println("Entity" + response.getEntity());
349 //assertEquals(200, response.getStatus());
350 assertEquals(401, response.getStatus());
354 public void Test3_createTable_duplicateTable() throws Exception {
355 JsonTable jsonTable = new JsonTable();
356 Map<String, String> consistencyInfo = new HashMap<>();
357 Map<String, String> fields = new HashMap<>();
358 fields.put("uuid", "text");
359 fields.put("emp_name", "text");
360 fields.put("emp_salary", "varint");
361 fields.put("PRIMARY KEY", "(emp_name)");
362 consistencyInfo.put("type", "eventual");
363 jsonTable.setConsistencyInfo(consistencyInfo);
364 jsonTable.setKeyspaceName(keyspaceName);
365 jsonTable.setPrimaryKey("emp_name");
366 String tableNameDup=tableName+"X";
367 jsonTable.setTableName(tableNameDup);
368 jsonTable.setFields(fields);
369 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
370 Response response = data.createTable("1", "1", "1",
371 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
372 jsonTable, keyspaceName, tableNameDup);
373 System.out.println("#######status for 1st time " + response.getStatus());
374 System.out.println("Entity" + response.getEntity());
376 Response response0 = data.createTable("1", "1", "1",
377 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
378 jsonTable, keyspaceName, tableNameDup);
379 // 400 is the duplicate status found in response
380 // Music 113 duplicate testing
381 //import static org.junit.Assert.assertNotEquals;
382 System.out.println("#######status for 2nd time " + response0.getStatus());
383 System.out.println("Entity" + response0.getEntity());
385 assertFalse("Duplicate table not created for "+tableNameDup, 200==response0.getStatus());
391 public void Test3_createTable1() throws Exception {
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_salary", "varint");
398 fields.put("PRIMARY KEY", "(emp_name)");
399 consistencyInfo.put("type", "eventual");
400 jsonTable.setConsistencyInfo(consistencyInfo);
401 jsonTable.setKeyspaceName(keyspaceName);
402 jsonTable.setPrimaryKey("emp_name");
403 jsonTable.setTableName(tableName);
404 jsonTable.setFields(fields);
405 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
406 Response response = data.createTable("1", "1", "1",
407 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
408 jsonTable, keyspaceName, tableName);
409 System.out.println("#######status is " + response.getStatus());
410 System.out.println("Entity" + response.getEntity());
411 assertEquals(401, response.getStatus());
416 public void Test3_createTable3() throws Exception {
417 JsonTable jsonTable = new JsonTable();
418 Map<String, String> consistencyInfo = new HashMap<>();
419 Map<String, String> fields = new HashMap<>();
420 fields.put("uuid", "text");
421 fields.put("emp_name", "text");
422 fields.put("emp_salary", "varint");
423 fields.put("PRIMARY KEY", "(emp_name)");
424 consistencyInfo.put("type", "eventual");
425 jsonTable.setConsistencyInfo(consistencyInfo);
426 jsonTable.setKeyspaceName(keyspaceName);
427 jsonTable.setPrimaryKey("emp_name");
428 jsonTable.setTableName(tableName);
429 jsonTable.setFields(fields);
430 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
431 Response response = data.createTable("1", "1", "1",
432 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
433 jsonTable, "wrong", tableName);
434 System.out.println("#######status is " + response.getStatus());
435 System.out.println("Entity" + response.getEntity());
436 assertEquals(401, response.getStatus());
439 // Improper parenthesis in key field
441 public void Test3_createTable_badParantesis() throws Exception {
442 String tableNameC ="testTable0";
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_salary", "varint");
449 fields.put("PRIMARY KEY", "(emp_name),emp_id)");
450 fields.put("emp_id", "varint");
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_id Desc");
457 jsonTable.setFields(fields);
458 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
459 Response response = data.createTable("1", "1", "1",
460 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
461 jsonTable, keyspaceName, tableNameC);
462 System.out.println("#######status is " + response.getStatus());
463 System.out.println("Entity" + response.getEntity());
464 //assertEquals(400, response.getStatus());
465 assertTrue(200 != response.getStatus());
469 // good clustering key
471 public void Test3_createTable_1_clusterKey_good() throws Exception {
472 String tableNameC ="testTableC1";
473 JsonTable jsonTable = new JsonTable();
474 Map<String, String> consistencyInfo = new HashMap<>();
475 Map<String, String> fields = new HashMap<>();
476 fields.put("uuid", "text");
477 fields.put("emp_name", "text");
478 fields.put("emp_salary", "varint");
479 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
480 consistencyInfo.put("type", "eventual");
481 jsonTable.setConsistencyInfo(consistencyInfo);
482 jsonTable.setKeyspaceName(keyspaceName);
483 // jsonTable.setPrimaryKey("emp_name");
484 jsonTable.setTableName(tableNameC);
485 jsonTable.setClusteringOrder("emp_salary ASC");
486 jsonTable.setFields(fields);
487 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
488 Response response = data.createTable("1", "1", "1",
489 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
490 jsonTable, keyspaceName, tableNameC);
491 System.out.println("#######status is " + response.getStatus());
492 System.out.println("Entity" + response.getEntity());
493 //assertEquals(200, response.getStatus());
494 assertEquals(401, response.getStatus());
497 // bad partition key=clustering key
499 public void Test3_createTable_2_clusterKey_bad() throws Exception {
500 String tableNameC ="testTableC2";
501 JsonTable jsonTable = new JsonTable();
502 Map<String, String> consistencyInfo = new HashMap<>();
503 Map<String, String> fields = new HashMap<>();
504 fields.put("uuid", "text");
505 fields.put("emp_name", "text");
506 fields.put("emp_salary", "varint");
507 fields.put("PRIMARY KEY", "((emp_name),emp_name)");
508 consistencyInfo.put("type", "eventual");
509 jsonTable.setConsistencyInfo(consistencyInfo);
510 jsonTable.setKeyspaceName(keyspaceName);
511 jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
512 jsonTable.setTableName(tableNameC);
513 jsonTable.setClusteringOrder("emp_salary ASC");
514 jsonTable.setFields(fields);
515 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
516 Response response = data.createTable("1", "1", "1",
517 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
518 jsonTable, keyspaceName, tableNameC);
519 System.out.println("#######status is " + response.getStatus());
520 System.out.println("Entity" + response.getEntity());
521 assertTrue(200 !=response.getStatus());
524 // good composite partition key,clustering key
526 public void Test3_createTable_3_partition_clusterKey_good() throws Exception {
527 String tableNameC ="testTableC3";
528 JsonTable jsonTable = new JsonTable();
529 Map<String, String> consistencyInfo = new HashMap<>();
530 Map<String, String> fields = new HashMap<>();
531 fields.put("uuid", "text");
532 fields.put("emp_name", "text");
533 fields.put("emp_id", "varint");
534 fields.put("emp_salary", "varint");
535 fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
536 consistencyInfo.put("type", "eventual");
537 jsonTable.setConsistencyInfo(consistencyInfo);
538 jsonTable.setKeyspaceName(keyspaceName);
539 jsonTable.setPrimaryKey("emp_name");
540 jsonTable.setTableName(tableNameC);
541 jsonTable.setClusteringOrder("emp_salary ASC");
542 jsonTable.setFields(fields);
543 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
544 Response response = data.createTable("1", "1", "1",
545 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
546 jsonTable, keyspaceName, tableNameC);
547 System.out.println("#######status is " + response.getStatus());
548 System.out.println("Entity" + response.getEntity());
549 //assertEquals(200, response.getStatus());
550 assertEquals(401, response.getStatus());
553 // bad - not all cols in order by of composite partition key,clustering key
555 public void Test3_createTable_4_clusteringOrder_bad() throws Exception {
556 String tableNameC ="testTableC4";
557 JsonTable jsonTable = new JsonTable();
558 Map<String, String> consistencyInfo = new HashMap<>();
559 Map<String, String> fields = new HashMap<>();
560 fields.put("uuid", "text");
561 fields.put("emp_name", "text");
562 fields.put("emp_id", "varint");
563 fields.put("emp_salary", "varint");
564 fields.put("PRIMARY KEY", "((emp_name),emp_id,emp_salary)");
565 consistencyInfo.put("type", "eventual");
566 jsonTable.setConsistencyInfo(consistencyInfo);
567 jsonTable.setKeyspaceName(keyspaceName);
568 jsonTable.setPrimaryKey("emp_name");
569 jsonTable.setTableName(tableNameC);
570 jsonTable.setClusteringOrder("emp_salary ASC");
571 jsonTable.setFields(fields);
572 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
573 Response response = data.createTable("1", "1", "1",
574 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
575 jsonTable, keyspaceName, tableNameC);
576 System.out.println("#######status is " + response.getStatus());
577 System.out.println("Entity" + response.getEntity());
578 assertTrue(200 != response.getStatus());
581 // bad - wrong cols in order by of composite partition key,clustering key
583 public void Test3_createTable_5_clusteringOrder_bad() throws Exception {
584 String tableNameC ="testTableC5";
585 JsonTable jsonTable = new JsonTable();
586 Map<String, String> consistencyInfo = new HashMap<>();
587 Map<String, String> fields = new HashMap<>();
588 fields.put("uuid", "text");
589 fields.put("emp_name", "text");
590 fields.put("emp_id", "varint");
591 fields.put("emp_salary", "varint");
592 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
593 consistencyInfo.put("type", "eventual");
594 jsonTable.setConsistencyInfo(consistencyInfo);
595 jsonTable.setKeyspaceName(keyspaceName);
596 jsonTable.setPrimaryKey("emp_name");
597 jsonTable.setTableName(tableNameC);
598 jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
599 jsonTable.setFields(fields);
600 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
601 Response response = data.createTable("1", "1", "1",
602 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
603 jsonTable, keyspaceName, tableNameC);
604 System.out.println("#######status is " + response.getStatus());
605 System.out.println("Entity" + response.getEntity());
606 assertTrue(200 != response.getStatus());
609 // bad - wrong cols in order by of composite partition key,clustering key
611 public void Test3_createTable_6_clusteringOrder_bad() throws Exception {
612 String tableNameC ="testTableC6";
613 JsonTable jsonTable = new JsonTable();
614 Map<String, String> consistencyInfo = new HashMap<>();
615 Map<String, String> fields = new HashMap<>();
616 fields.put("uuid", "text");
617 fields.put("emp_name", "text");
618 fields.put("emp_id", "varint");
619 fields.put("emp_salary", "varint");
620 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
621 consistencyInfo.put("type", "eventual");
622 jsonTable.setConsistencyInfo(consistencyInfo);
623 jsonTable.setKeyspaceName(keyspaceName);
624 jsonTable.setPrimaryKey("((uuid,emp_name),emp_id,emp_salary)"); // overridden by
625 jsonTable.setTableName(tableNameC);
626 jsonTable.setClusteringOrder("emp_id desc, emp_salary ASC,uuid desc");
627 jsonTable.setFields(fields);
628 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
629 Response response = data.createTable("1", "1", "1",
630 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
631 jsonTable, keyspaceName, tableNameC);
632 System.out.println("#######status is " + response.getStatus());
633 System.out.println("Entity" + response.getEntity());
634 assertTrue(200 != response.getStatus());
638 // good clustering key, need to pass queryparameter
640 public void Test3_createTableIndex_1() throws Exception {
641 String tableNameC ="testTableCinx";
642 JsonTable jsonTable = new JsonTable();
643 Map<String, String> consistencyInfo = new HashMap<>();
644 Map<String, String> fields = new HashMap<>();
645 fields.put("uuid", "text");
646 fields.put("emp_name", "text");
647 fields.put("emp_salary", "varint");
648 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
649 consistencyInfo.put("type", "eventual");
650 jsonTable.setConsistencyInfo(consistencyInfo);
651 jsonTable.setKeyspaceName(keyspaceName);
652 // jsonTable.setPrimaryKey("emp_name");
653 jsonTable.setTableName(tableNameC);
654 jsonTable.setClusteringOrder("emp_salary ASC");
655 jsonTable.setFields(fields);
656 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
657 Response response = data.createTable("1", "1", "1",
658 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
659 jsonTable, keyspaceName, tableNameC);
660 System.out.println("#######status is " + response.getStatus());
661 System.out.println("Entity" + response.getEntity());
662 // if 200 print to log otherwise fail assertEquals(200, response.getStatus());
663 // info.setQueryParameters("index_name=inx_uuid");
664 Map<String,String> queryParametersMap =new HashMap<String, String>();
666 queryParametersMap.put("index_name","inxuuid");
667 // Mockito.when(info.getQueryParameters()).thenReturn(new MultivaluedMap<String, String>(queryParametersMap));
669 response = data.createIndex("1", "1", "1",
670 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
671 keyspaceName, tableNameC,"uuid",info);
672 assertEquals(401, response.getStatus());
673 } catch (NullPointerException e) {
679 public void Test4_insertIntoTable() throws Exception {
680 JsonInsert jsonInsert = new JsonInsert();
681 Map<String, String> consistencyInfo = new HashMap<>();
682 Map<String, Object> values = new HashMap<>();
683 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
684 values.put("emp_name", "testName");
685 values.put("emp_salary", 500);
686 consistencyInfo.put("type", "eventual");
687 jsonInsert.setConsistencyInfo(consistencyInfo);
688 jsonInsert.setKeyspaceName(keyspaceName);
689 jsonInsert.setTableName(tableName);
690 jsonInsert.setValues(values);
691 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
692 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
693 appName, authorization, jsonInsert, keyspaceName, tableName);
694 //assertEquals(200, response.getStatus());
695 assertEquals(401, response.getStatus());
699 public void Test4_insertIntoTable2() throws Exception {
700 JsonInsert jsonInsert = new JsonInsert();
701 Map<String, String> consistencyInfo = new HashMap<>();
702 Map<String, Object> values = new HashMap<>();
703 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
704 values.put("emp_name", "test1");
705 values.put("emp_salary", 1500);
706 consistencyInfo.put("type", "eventual");
707 jsonInsert.setConsistencyInfo(consistencyInfo);
708 jsonInsert.setKeyspaceName(keyspaceName);
709 jsonInsert.setTableName(tableName);
710 jsonInsert.setValues(values);
711 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
712 Response response = data.insertIntoTable("1", "1", "1",
713 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
714 jsonInsert, keyspaceName, tableName);
715 //assertEquals(200, response.getStatus());
716 assertEquals(401, response.getStatus());
721 public void Test4_insertIntoTable3() throws Exception {
722 JsonInsert jsonInsert = new JsonInsert();
723 Map<String, String> consistencyInfo = new HashMap<>();
724 Map<String, Object> values = new HashMap<>();
725 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
726 values.put("emp_name", "test1");
727 values.put("emp_salary", 1500);
728 consistencyInfo.put("type", "eventual");
729 jsonInsert.setConsistencyInfo(consistencyInfo);
730 jsonInsert.setKeyspaceName(keyspaceName);
731 jsonInsert.setTableName(tableName);
732 jsonInsert.setValues(values);
733 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
734 Response response = data.insertIntoTable("1", "1", "1",
735 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
736 jsonInsert, keyspaceName, tableName);
737 assertEquals(401, response.getStatus());
742 public void Test4_insertIntoTable4() throws Exception {
743 JsonInsert jsonInsert = new JsonInsert();
744 Map<String, String> consistencyInfo = new HashMap<>();
745 Map<String, Object> values = new HashMap<>();
746 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
747 values.put("emp_name", "test1");
748 values.put("emp_salary", 1500);
749 consistencyInfo.put("type", "eventual");
750 jsonInsert.setConsistencyInfo(consistencyInfo);
751 jsonInsert.setKeyspaceName(keyspaceName);
752 jsonInsert.setTableName(tableName);
753 jsonInsert.setValues(values);
754 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
755 Response response = data.insertIntoTable("1", "1", "1",
756 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
757 jsonInsert, keyspaceName, "wrong");
758 assertEquals(401, response.getStatus());
763 public void Test5_updateTable() throws Exception {
764 JsonUpdate jsonUpdate = new JsonUpdate();
765 Map<String, String> consistencyInfo = new HashMap<>();
766 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
767 Map<String, Object> values = new HashMap<>();
768 row.add("emp_name", "testName");
769 values.put("emp_salary", 2500);
770 consistencyInfo.put("type", "atomic");
771 jsonUpdate.setConsistencyInfo(consistencyInfo);
772 jsonUpdate.setKeyspaceName(keyspaceName);
773 jsonUpdate.setTableName(tableName);
774 jsonUpdate.setValues(values);
775 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
776 //Mockito.when(info.getQueryParameters()).thenReturn(row);
777 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
778 authorization, jsonUpdate, keyspaceName, tableName, info);
779 //assertEquals(200, response.getStatus());
780 assertEquals(401, response.getStatus());
783 // need mock code to create error for MusicCore methods
785 public void Test5_updateTableAuthE() throws Exception {
786 //MockitoAnnotations.initMocks(this);
787 JsonUpdate jsonUpdate = new JsonUpdate();
788 Map<String, String> consistencyInfo = new HashMap<>();
789 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
790 Map<String, Object> values = new HashMap<>();
791 row.add("emp_name", "testName");
792 values.put("emp_salary", 2500);
793 consistencyInfo.put("type", "atomic");
794 jsonUpdate.setConsistencyInfo(consistencyInfo);
795 jsonUpdate.setKeyspaceName(keyspaceName);
796 jsonUpdate.setTableName(tableName);
797 jsonUpdate.setValues(values);
798 //add ttl & timestamp
799 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
800 //Mockito.when(info.getQueryParameters()).thenReturn(row);
801 //Map<String, Object> m1= new HashMap<>() ;
802 //Mockito.when(MusicCore.autheticateUser(appName,userId,password,keyspaceName,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6","updateTable")).thenReturn(m1);
804 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
805 authorization, jsonUpdate, keyspaceName, tableName, info);
806 //assertEquals(200, response.getStatus());
807 assertEquals(401, response.getStatus());
808 } catch(NullPointerException e) {
814 public void Test5_updateTableAuthException1() throws Exception {
815 JsonUpdate jsonUpdate = new JsonUpdate();
816 Map<String, String> consistencyInfo = new HashMap<>();
817 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
818 Map<String, Object> values = new HashMap<>();
819 row.add("emp_name", "testName");
820 values.put("emp_salary", 2500);
821 consistencyInfo.put("type", "atomic");
822 jsonUpdate.setConsistencyInfo(consistencyInfo);
823 jsonUpdate.setKeyspaceName(keyspaceName);
824 jsonUpdate.setTableName(tableName);
825 jsonUpdate.setValues(values);
827 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
828 //Mockito.when(info.getQueryParameters()).thenReturn(row);
829 String authDatax = ":";//+password;
830 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
832 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
833 authorizationx, jsonUpdate, keyspaceName, tableName, info);
834 assertEquals(200, response.getStatus());
835 } catch(RuntimeException e) {
836 System.out.println("Update table Runtime exception="+e);
842 public void Test5_updateTableAuthEmpty() throws Exception {
843 JsonUpdate jsonUpdate = new JsonUpdate();
844 Map<String, String> consistencyInfo = new HashMap<>();
845 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
846 Map<String, Object> values = new HashMap<>();
847 row.add("emp_name", "testName");
848 values.put("emp_salary", 2500);
849 consistencyInfo.put("type", "atomic");
850 jsonUpdate.setConsistencyInfo(consistencyInfo);
851 jsonUpdate.setKeyspaceName(keyspaceName);
852 jsonUpdate.setTableName(tableName);
853 jsonUpdate.setValues(values);
855 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
856 //Mockito.when(info.getQueryParameters()).thenReturn(row);
857 String authDatax =":"+password;
858 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
859 String appNamex="xx";
861 // Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
862 Response response = data.updateTable("1", "1", "1", "", appNamex,
863 authorizationx, jsonUpdate, keyspaceName, tableName, info);
864 assertEquals(200, response.getStatus());
865 } catch(RuntimeException e) {
866 System.out.println("Update table Runtime exception="+e);
873 public void Test6_select() throws Exception {
874 JsonSelect jsonSelect = new JsonSelect();
875 Map<String, String> consistencyInfo = new HashMap<>();
876 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
877 row.add("emp_name", "testName");
878 consistencyInfo.put("type", "atomic");
879 jsonSelect.setConsistencyInfo(consistencyInfo);
880 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
881 //Mockito.when(info.getQueryParameters()).thenReturn(row);
882 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
883 appName, authorization, keyspaceName, tableName, info);
884 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
885 HashMap<String, Object> result = map.get("result");
886 //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
890 public void Test6_selectCritical() throws Exception {
891 JsonInsert jsonInsert = new JsonInsert();
892 Map<String, String> consistencyInfo = new HashMap<>();
893 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
894 row.add("emp_name", "testName");
895 consistencyInfo.put("type", "atomic");
896 jsonInsert.setConsistencyInfo(consistencyInfo);
897 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
898 //Mockito.when(info.getQueryParameters()).thenReturn(row);
899 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
900 appName, authorization, jsonInsert, keyspaceName, tableName,info);
901 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
902 HashMap<String, Object> result = map.get("result");
903 //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
907 public void Test6_deleteFromTable() throws Exception {
908 JsonDelete jsonDelete = new JsonDelete();
909 Map<String, String> consistencyInfo = new HashMap<>();
910 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
911 row.add("emp_name", "test1");
912 consistencyInfo.put("type", "atomic");
913 jsonDelete.setConsistencyInfo(consistencyInfo);
914 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
915 //Mockito.when(info.getQueryParameters()).thenReturn(row);
916 Response response = data.deleteFromTable("1", "1", "1",
917 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
918 jsonDelete, keyspaceName, tableName, info);
919 //assertEquals(200, response.getStatus());
920 assertEquals(401, response.getStatus());
926 public void Test6_deleteFromTable1() throws Exception {
927 JsonDelete jsonDelete = new JsonDelete();
928 Map<String, String> consistencyInfo = new HashMap<>();
929 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
930 consistencyInfo.put("type", "atomic");
931 jsonDelete.setConsistencyInfo(consistencyInfo);
932 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
933 Mockito.when(info.getQueryParameters()).thenReturn(row);
934 Response response = data.deleteFromTable("1", "1", "1",
935 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
936 jsonDelete, keyspaceName, tableName, info);
937 assertEquals(400, response.getStatus());
942 public void Test6_deleteFromTable2() throws Exception {
943 JsonDelete jsonDelete = new JsonDelete();
944 Map<String, String> consistencyInfo = new HashMap<>();
945 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
946 row.add("emp_name", "test1");
947 consistencyInfo.put("type", "atomic");
948 jsonDelete.setConsistencyInfo(consistencyInfo);
949 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
950 //Mockito.when(info.getQueryParameters()).thenReturn(row);
951 Response response = data.deleteFromTable("1", "1", "1",
952 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
953 null, keyspaceName, tableName, info);
954 assertEquals(401, response.getStatus());
958 public void Test7_dropTable() throws Exception {
959 JsonTable jsonTable = new JsonTable();
960 Map<String, String> consistencyInfo = new HashMap<>();
961 consistencyInfo.put("type", "atomic");
962 jsonTable.setConsistencyInfo(consistencyInfo);
963 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
964 Response response = data.dropTable("1", "1", "1",
965 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
966 keyspaceName, tableName);
967 //assertEquals(200, response.getStatus());
968 assertEquals(401, response.getStatus());
973 public void Test8_deleteKeyspace() throws Exception {
974 JsonKeySpace jsonKeyspace = new JsonKeySpace();
975 Map<String, String> consistencyInfo = new HashMap<>();
976 Map<String, Object> replicationInfo = new HashMap<>();
977 consistencyInfo.put("type", "eventual");
978 replicationInfo.put("class", "SimpleStrategy");
979 replicationInfo.put("replication_factor", 1);
980 jsonKeyspace.setConsistencyInfo(consistencyInfo);
981 jsonKeyspace.setDurabilityOfWrites("true");
982 jsonKeyspace.setKeyspaceName("TestApp1");
983 jsonKeyspace.setReplicationInfo(replicationInfo);
984 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
986 * Response response = data.dropKeySpace("1", "1", "1",
987 * "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,appName, keyspaceName);
988 * assertEquals(200, response.getStatus());
993 public void Test8_deleteKeyspace2() throws Exception {
994 JsonKeySpace jsonKeyspace = new JsonKeySpace();
995 Map<String, String> consistencyInfo = new HashMap<>();
996 Map<String, Object> replicationInfo = new HashMap<>();
997 consistencyInfo.put("type", "eventual");
998 replicationInfo.put("class", "SimpleStrategy");
999 replicationInfo.put("replication_factor", 1);
1000 jsonKeyspace.setConsistencyInfo(consistencyInfo);
1001 jsonKeyspace.setDurabilityOfWrites("true");
1002 jsonKeyspace.setKeyspaceName("TestApp1");
1003 jsonKeyspace.setReplicationInfo(replicationInfo);
1004 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1005 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1006 wrongAuthorization, appName, keyspaceName);
1007 assertEquals(400, response.getStatus());
1011 public void Test8_deleteKeyspace3() throws Exception {
1012 JsonKeySpace jsonKeyspace = new JsonKeySpace();
1013 Map<String, String> consistencyInfo = new HashMap<>();
1014 Map<String, Object> replicationInfo = new HashMap<>();
1015 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1017 * Response response = data.dropKeySpace("1", "1", "1",
1018 * "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization, appName,
1019 * keyspaceName); assertEquals(400, response.getStatus());
1026 public void Test6_onboard() throws Exception {
1027 JsonOnboard jsonOnboard = new JsonOnboard();
1028 jsonOnboard.setAppname("TestApp2");
1029 jsonOnboard.setIsAAF("false");
1030 jsonOnboard.setUserId("TestUser2");
1031 jsonOnboard.setPassword("TestPassword2");
1032 Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard, null).getEntity();
1033 resultMap.containsKey("success");
1034 //onboardUUID = resultMap.get("Generated AID").toString();
1035 //assertEquals("Your application TestApp2 has been onboarded with MUSIC.", resultMap.get("Success"));
1039 public void Test6_onboard1() throws Exception {
1040 JsonOnboard jsonOnboard = new JsonOnboard();
1041 jsonOnboard.setIsAAF("false");
1042 jsonOnboard.setUserId("TestUser2");
1043 jsonOnboard.setPassword("TestPassword2");
1044 Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard, null).getEntity();
1045 resultMap.containsKey("success");
1046 System.out.println("--->" + resultMap.toString());
1047 //assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
1052 public void Test7_onboardSearch() throws Exception {
1053 JsonOnboard jsonOnboard = new JsonOnboard();
1054 jsonOnboard.setAppname("TestApp2");
1055 jsonOnboard.setIsAAF("false");
1056 jsonOnboard.setAid(onboardUUID);
1057 Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard, null).getEntity();
1058 resultMap.containsKey("success");
1059 //assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
1060 assertEquals(null, resultMap.get(onboardUUID));
1066 public void Test7_onboardSearch1() throws Exception {
1067 JsonOnboard jsonOnboard = new JsonOnboard();
1068 jsonOnboard.setIsAAF("false");
1069 jsonOnboard.setAid(onboardUUID);
1070 Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard, null).getEntity();
1071 System.out.println("--->" + resultMap.toString());
1072 //resultMap.containsKey("success");
1073 resultMap.containsKey(null);
1074 //assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
1075 assertEquals(null, resultMap.get(onboardUUID));
1080 public void Test8_onboardUpdate() throws Exception {
1081 JsonOnboard jsonOnboard = new JsonOnboard();
1082 jsonOnboard.setIsAAF("false");
1083 jsonOnboard.setUserId("TestUser3");
1084 jsonOnboard.setPassword("TestPassword3");
1085 jsonOnboard.setAid(onboardUUID);
1086 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard, null).getEntity();
1087 System.out.println("--->" + resultMap.toString());
1088 resultMap.containsKey("success");
1089 //assertEquals("Your application has been updated successfully", resultMap.get("Success"));
1090 assertEquals(null, resultMap.get("Success"));
1095 public void Test8_onboardUpdate1() throws Exception {
1096 JsonOnboard jsonOnboard = new JsonOnboard();
1097 jsonOnboard.setIsAAF("false");
1098 jsonOnboard.setUserId("TestUser3");
1099 jsonOnboard.setPassword("TestPassword3");
1100 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard, null).getEntity();
1101 System.out.println("--->" + resultMap.toString());
1102 resultMap.containsKey("success");
1103 //assertEquals("Please make sure Aid is present", resultMap.get("Exception"));
1104 assertEquals(null, resultMap.get("Exception"));
1109 public void Test8_onboardUpdate2() throws Exception {
1110 JsonOnboard jsonOnboard = new JsonOnboard();
1111 jsonOnboard.setAppname("TestApp2");
1112 jsonOnboard.setIsAAF("false");
1113 jsonOnboard.setUserId("TestUser3");
1114 jsonOnboard.setPassword("TestPassword3");
1115 jsonOnboard.setAid(onboardUUID);
1116 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard, null).getEntity();
1117 resultMap.containsKey("success");
1118 System.out.println("--->" + resultMap.toString());
1119 //assertEquals("Application TestApp2 has already been onboarded. Please contact admin.", resultMap.get("Exception"));
1120 assertEquals(null, resultMap.get("Exception"));
1125 public void Test8_onboardUpdate3() throws Exception {
1126 JsonOnboard jsonOnboard = new JsonOnboard();
1127 jsonOnboard.setAid(onboardUUID);
1128 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard, null).getEntity();
1129 //assertTrue(resultMap.containsKey("Exception") );
1133 public void Test9_onboardDelete() throws Exception {
1134 JsonOnboard jsonOnboard = new JsonOnboard();
1135 jsonOnboard.setAppname("TestApp2");
1136 jsonOnboard.setAid(onboardUUID);
1137 Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard, null).getEntity();
1138 resultMap.containsKey("success");
1139 //assertEquals("Your application has been deleted successfully", resultMap.get("Success"));
1140 assertEquals(null, resultMap.get("Success"));
1144 public void Test9_onboardDelete1() throws Exception {
1145 JsonOnboard jsonOnboard = new JsonOnboard();
1146 Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard, null).getEntity();
1147 //assertTrue(resultMap.containsKey("Exception"));
1152 public void Test3_createLockReference() throws Exception {
1153 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1154 Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1",authorization, null, appName).getEntity();
1155 @SuppressWarnings("unchecked")
1156 Map<String, Object> resultMap1 = (Map<String, Object>) resultMap.get("lock");
1157 lockId = (String) resultMap1.get("lock");
1158 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1163 public void Test4_accquireLock() throws Exception {
1164 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1165 Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLock(lockId,"1","1",authorization, null, appName).getEntity();
1166 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1171 public void Test5_currentLockHolder() throws Exception {
1172 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1173 Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder(lockName,"1","1",authorization, null, appName).getEntity();
1174 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
1179 public void Test7_unLock() throws Exception {
1180 //Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1181 Map<String, Object> resultMap = (Map<String, Object>) lock.unLock(lockId,"1","1",authorization, null, appName).getEntity();
1182 assertEquals(ResultType.SUCCESS, resultMap.get("status"));