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.assertTrue;
25 import java.util.HashMap;
26 import java.util.List;
28 import java.util.UUID;
29 import javax.servlet.http.HttpServletResponse;
30 import javax.ws.rs.core.MultivaluedMap;
31 import javax.ws.rs.core.Response;
32 import javax.ws.rs.core.UriInfo;
33 import org.apache.curator.test.TestingServer;
34 import org.junit.AfterClass;
35 import org.junit.BeforeClass;
36 import org.junit.FixMethodOrder;
37 import org.junit.Test;
38 import org.junit.runner.RunWith;
39 import org.junit.runners.MethodSorters;
40 import org.mindrot.jbcrypt.BCrypt;
41 import org.mockito.Mock;
42 import org.mockito.Mockito;
43 import org.mockito.runners.MockitoJUnitRunner;
44 import org.onap.music.datastore.PreparedQueryObject;
45 import org.onap.music.datastore.jsonobjects.JsonDelete;
46 import org.onap.music.datastore.jsonobjects.JsonInsert;
47 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
48 import org.onap.music.datastore.jsonobjects.JsonOnboard;
49 import org.onap.music.datastore.jsonobjects.JsonSelect;
50 import org.onap.music.datastore.jsonobjects.JsonTable;
51 import org.onap.music.datastore.jsonobjects.JsonUpdate;
52 import org.onap.music.lockingservice.MusicLockingService;
53 import org.onap.music.main.MusicCore;
54 import org.onap.music.main.MusicUtil;
55 import org.onap.music.main.ResultType;
56 import org.onap.music.rest.RestMusicAdminAPI;
57 import org.onap.music.rest.RestMusicDataAPI;
58 import org.onap.music.rest.RestMusicLocksAPI;
59 import com.datastax.driver.core.DataType;
60 import com.datastax.driver.core.ResultSet;
61 import com.datastax.driver.core.Row;
62 import com.sun.jersey.core.util.MultivaluedMapImpl;
64 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
65 @RunWith(MockitoJUnitRunner.class)
66 public class TestRestMusicData {
68 RestMusicDataAPI data = new RestMusicDataAPI();
69 RestMusicAdminAPI admin = new RestMusicAdminAPI();
70 RestMusicLocksAPI lock = new RestMusicLocksAPI();
71 static PreparedQueryObject testObject;
72 static TestingServer zkServer;
75 HttpServletResponse http;
80 static String appName = "TestApp";
81 static String userId = "TestUser";
82 static String password = "TestPassword";
83 static boolean isAAF = false;
84 static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
85 static String keyspaceName = "testCassa";
86 static String tableName = "employees";
87 static String xLatestVersion = "X-latestVersion";
88 static String onboardUUID = null;
89 static String lockId = null;
90 static String lockName = "testCassa.employees.sample3";
93 public static void init() throws Exception {
95 MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
96 zkServer = new TestingServer(2181, new File("/tmp/zk"));
97 MusicCore.mLockHandle = new MusicLockingService();
98 } catch (Exception e) {
104 public static void tearDownAfterClass() throws Exception {
105 System.out.println("After class");
106 testObject = new PreparedQueryObject();
107 testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
108 MusicCore.eventualPut(testObject);
109 testObject = new PreparedQueryObject();
110 testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
111 MusicCore.eventualPut(testObject);
112 MusicCore.mDstoreHandle.close();
113 MusicCore.mLockHandle.getzkLockHandle().close();
114 MusicCore.mLockHandle.close();
119 public void Test1_createKeyspace() throws Exception {
120 testObject = new PreparedQueryObject();
121 testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = "
122 + "{'class' : 'SimpleStrategy' , "
123 + "'replication_factor': 1} AND DURABLE_WRITES = true");
124 MusicCore.eventualPut(testObject);
125 testObject = new PreparedQueryObject();
126 testObject.appendQueryString(
127 "CREATE TABLE admin.keyspace_master (" + " uuid uuid, keyspace_name text,"
128 + " application_name text, is_api boolean,"
129 + " password text, username text,"
130 + " is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
131 MusicCore.eventualPut(testObject);
133 testObject = new PreparedQueryObject();
134 testObject.appendQueryString(
135 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
136 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
137 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
138 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
139 MusicUtil.DEFAULTKEYSPACENAME));
140 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
141 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
142 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
143 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
144 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
145 MusicCore.eventualPut(testObject);
147 testObject = new PreparedQueryObject();
148 testObject.appendQueryString(
149 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
150 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
151 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
152 UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
153 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
154 MusicUtil.DEFAULTKEYSPACENAME));
155 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
156 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
157 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
158 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
159 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
160 MusicCore.eventualPut(testObject);
162 testObject = new PreparedQueryObject();
163 testObject.appendQueryString(
164 "select uuid from admin.keyspace_master where application_name = ? allow filtering");
165 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
166 ResultSet rs = MusicCore.get(testObject);
167 List<Row> rows = rs.all();
168 if (rows.size() > 0) {
169 System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
174 public void Test2_createKeyspace() throws Exception {
175 JsonKeySpace jsonKeyspace = new JsonKeySpace();
176 Map<String, String> consistencyInfo = new HashMap<>();
177 Map<String, Object> replicationInfo = new HashMap<>();
178 consistencyInfo.put("type", "eventual");
179 replicationInfo.put("class", "SimpleStrategy");
180 replicationInfo.put("replication_factor", 1);
181 jsonKeyspace.setConsistencyInfo(consistencyInfo);
182 jsonKeyspace.setDurabilityOfWrites("true");
183 jsonKeyspace.setKeyspaceName(keyspaceName);
184 jsonKeyspace.setReplicationInfo(replicationInfo);
185 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
186 Response response = data.createKeySpace("1", "1", "1", null, appName, userId,
187 password, jsonKeyspace, keyspaceName);
188 System.out.println("#######status is " + response.getStatus());
189 System.out.println("Entity" + response.getEntity());
190 assertEquals(200,response.getStatus());
194 public void Test2_createKeyspace0() throws Exception {
195 JsonKeySpace jsonKeyspace = new JsonKeySpace();
196 Map<String, String> consistencyInfo = new HashMap<>();
197 Map<String, Object> replicationInfo = new HashMap<>();
198 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
199 Response response = data.createKeySpace("1", "1", "1", null, appName, userId,
200 password, jsonKeyspace, keyspaceName);
201 System.out.println("#######status is " + response.getStatus());
202 System.out.println("Entity" + response.getEntity());
203 assertEquals(400,response.getStatus());
205 //MusicCore.autheticateUser
207 public void Test2_createKeyspace01() throws Exception {
208 JsonKeySpace jsonKeyspace = new JsonKeySpace();
209 Map<String, String> consistencyInfo = new HashMap<>();
210 Map<String, Object> replicationInfo = new HashMap<>();
211 String appName1 = "test";
212 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
213 Response response = data.createKeySpace("1", "1", "1", null, appName1, userId,
214 password, jsonKeyspace, keyspaceName);
215 System.out.println("#######status is " + response.getStatus());
216 System.out.println("Entity" + response.getEntity());
217 assertEquals(401,response.getStatus());
221 public void Test3_createKeyspace1() throws Exception {
222 JsonKeySpace jsonKeyspace = new JsonKeySpace();
223 Map<String, String> consistencyInfo = new HashMap<>();
224 Map<String, Object> replicationInfo = new HashMap<>();
225 consistencyInfo.put("type", "eventual");
226 replicationInfo.put("class", "SimpleStrategy");
227 replicationInfo.put("replication_factor", 1);
228 jsonKeyspace.setConsistencyInfo(consistencyInfo);
229 jsonKeyspace.setDurabilityOfWrites("true");
230 jsonKeyspace.setKeyspaceName("TestApp1");
231 jsonKeyspace.setReplicationInfo(replicationInfo);
232 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
233 Response response = data.createKeySpace("1", "1", "1", null, "TestApp1",
234 "TestUser1", password, jsonKeyspace, keyspaceName);
235 System.out.println("#######status is " + response.getStatus());
236 System.out.println("Entity" + response.getEntity());
237 assertEquals(400,response.getStatus());
241 public void Test3_createTable() throws Exception {
242 JsonTable jsonTable = new JsonTable();
243 Map<String, String> consistencyInfo = new HashMap<>();
244 Map<String, String> fields = new HashMap<>();
245 fields.put("uuid", "text");
246 fields.put("emp_name", "text");
247 fields.put("emp_salary", "varint");
248 fields.put("PRIMARY KEY", "(emp_name)");
249 consistencyInfo.put("type", "eventual");
250 jsonTable.setConsistencyInfo(consistencyInfo);
251 jsonTable.setKeyspaceName(keyspaceName);
252 jsonTable.setPrimaryKey("emp_name");
253 jsonTable.setTableName(tableName);
254 jsonTable.setFields(fields);
255 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
256 Response response = data.createTable("1", "1", "1",
257 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
258 jsonTable, keyspaceName, tableName);
259 System.out.println("#######status is " + response.getStatus());
260 System.out.println("Entity" + response.getEntity());
261 assertEquals(200, response.getStatus());
266 public void Test3_createTable1() throws Exception {
267 JsonTable jsonTable = new JsonTable();
268 Map<String, String> consistencyInfo = new HashMap<>();
269 Map<String, String> fields = new HashMap<>();
270 fields.put("uuid", "text");
271 fields.put("emp_name", "text");
272 fields.put("emp_salary", "varint");
273 fields.put("PRIMARY KEY", "(emp_name)");
274 consistencyInfo.put("type", "eventual");
275 jsonTable.setConsistencyInfo(consistencyInfo);
276 jsonTable.setKeyspaceName(keyspaceName);
277 jsonTable.setPrimaryKey("emp_name");
278 jsonTable.setTableName(tableName);
279 jsonTable.setFields(fields);
280 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
281 Response response = data.createTable("1", "1", "1",
282 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, "wrong",
283 jsonTable, keyspaceName, tableName);
284 System.out.println("#######status is " + response.getStatus());
285 System.out.println("Entity" + response.getEntity());
286 assertEquals(401, response.getStatus());
291 public void Test3_createTable2() throws Exception {
292 JsonTable jsonTable = new JsonTable();
293 Map<String, String> consistencyInfo = new HashMap<>();
294 Map<String, String> fields = new HashMap<>();
295 fields.put("uuid", "text");
296 fields.put("emp_name", "text");
297 fields.put("emp_salary", "varint");
298 fields.put("PRIMARY KEY", "(emp_name)");
299 consistencyInfo.put("type", "eventual");
300 jsonTable.setConsistencyInfo(consistencyInfo);
301 jsonTable.setKeyspaceName(keyspaceName);
302 jsonTable.setPrimaryKey("emp_name");
303 jsonTable.setTableName(tableName);
304 jsonTable.setFields(fields);
305 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
306 Response response = data.createTable("1", "1", "1",
307 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
308 jsonTable, "wrong", tableName);
309 System.out.println("#######status is " + response.getStatus());
310 System.out.println("Entity" + response.getEntity());
311 assertEquals(401, response.getStatus());
317 public void Test4_insertIntoTable() throws Exception {
318 JsonInsert jsonInsert = new JsonInsert();
319 Map<String, String> consistencyInfo = new HashMap<>();
320 Map<String, Object> values = new HashMap<>();
321 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
322 values.put("emp_name", "testName");
323 values.put("emp_salary", 500);
324 consistencyInfo.put("type", "eventual");
325 jsonInsert.setConsistencyInfo(consistencyInfo);
326 jsonInsert.setKeyspaceName(keyspaceName);
327 jsonInsert.setTableName(tableName);
328 jsonInsert.setValues(values);
329 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
330 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
331 appName, userId, password, jsonInsert, keyspaceName, tableName);
332 assertEquals(200, response.getStatus());
336 public void Test4_insertIntoTable2() throws Exception {
337 JsonInsert jsonInsert = new JsonInsert();
338 Map<String, String> consistencyInfo = new HashMap<>();
339 Map<String, Object> values = new HashMap<>();
340 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
341 values.put("emp_name", "test1");
342 values.put("emp_salary", 1500);
343 consistencyInfo.put("type", "eventual");
344 jsonInsert.setConsistencyInfo(consistencyInfo);
345 jsonInsert.setKeyspaceName(keyspaceName);
346 jsonInsert.setTableName(tableName);
347 jsonInsert.setValues(values);
348 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
349 Response response = data.insertIntoTable("1", "1", "1",
350 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
351 jsonInsert, keyspaceName, tableName);
352 assertEquals(200, response.getStatus());
357 public void Test4_insertIntoTable3() throws Exception {
358 JsonInsert jsonInsert = new JsonInsert();
359 Map<String, String> consistencyInfo = new HashMap<>();
360 Map<String, Object> values = new HashMap<>();
361 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
362 values.put("emp_name", "test1");
363 values.put("emp_salary", 1500);
364 consistencyInfo.put("type", "eventual");
365 jsonInsert.setConsistencyInfo(consistencyInfo);
366 jsonInsert.setKeyspaceName(keyspaceName);
367 jsonInsert.setTableName(tableName);
368 jsonInsert.setValues(values);
369 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
370 Response response = data.insertIntoTable("1", "1", "1",
371 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, "wrong",
372 jsonInsert, keyspaceName, tableName);
373 assertEquals(401, response.getStatus());
378 public void Test4_insertIntoTable4() throws Exception {
379 JsonInsert jsonInsert = new JsonInsert();
380 Map<String, String> consistencyInfo = new HashMap<>();
381 Map<String, Object> values = new HashMap<>();
382 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
383 values.put("emp_name", "test1");
384 values.put("emp_salary", 1500);
385 consistencyInfo.put("type", "eventual");
386 jsonInsert.setConsistencyInfo(consistencyInfo);
387 jsonInsert.setKeyspaceName(keyspaceName);
388 jsonInsert.setTableName(tableName);
389 jsonInsert.setValues(values);
390 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
391 Response response = data.insertIntoTable("1", "1", "1",
392 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
393 jsonInsert, keyspaceName, "wrong");
394 assertEquals(400, response.getStatus());
400 public void Test5_updateTable() throws Exception {
401 JsonUpdate jsonUpdate = new JsonUpdate();
402 Map<String, String> consistencyInfo = new HashMap<>();
403 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
404 Map<String, Object> values = new HashMap<>();
405 row.add("emp_name", "testName");
406 values.put("emp_salary", 2500);
407 consistencyInfo.put("type", "atomic");
408 jsonUpdate.setConsistencyInfo(consistencyInfo);
409 jsonUpdate.setKeyspaceName(keyspaceName);
410 jsonUpdate.setTableName(tableName);
411 jsonUpdate.setValues(values);
412 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
413 Mockito.when(info.getQueryParameters()).thenReturn(row);
414 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
415 userId, password, jsonUpdate, keyspaceName, tableName, info);
416 assertEquals(200, response.getStatus());
420 public void Test6_select() throws Exception {
421 JsonSelect jsonSelect = new JsonSelect();
422 Map<String, String> consistencyInfo = new HashMap<>();
423 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
424 row.add("emp_name", "testName");
425 consistencyInfo.put("type", "atomic");
426 jsonSelect.setConsistencyInfo(consistencyInfo);
427 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
428 Mockito.when(info.getQueryParameters()).thenReturn(row);
429 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
430 appName, userId, password, keyspaceName, tableName, info);
431 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
432 HashMap<String, Object> result = map.get("result");
433 assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
437 public void Test6_selectCritical() throws Exception {
438 JsonInsert jsonInsert = new JsonInsert();
439 Map<String, String> consistencyInfo = new HashMap<>();
440 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
441 row.add("emp_name", "testName");
442 consistencyInfo.put("type", "atomic");
443 jsonInsert.setConsistencyInfo(consistencyInfo);
444 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
445 Mockito.when(info.getQueryParameters()).thenReturn(row);
446 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
447 appName, userId, password, jsonInsert, keyspaceName, tableName,info);
448 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
449 HashMap<String, Object> result = map.get("result");
450 assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
454 public void Test6_deleteFromTable() throws Exception {
455 JsonDelete jsonDelete = new JsonDelete();
456 Map<String, String> consistencyInfo = new HashMap<>();
457 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
458 row.add("emp_name", "test1");
459 consistencyInfo.put("type", "atomic");
460 jsonDelete.setConsistencyInfo(consistencyInfo);
461 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
462 Mockito.when(info.getQueryParameters()).thenReturn(row);
463 Response response = data.deleteFromTable("1", "1", "1",
464 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
465 jsonDelete, keyspaceName, tableName, info);
466 assertEquals(200, response.getStatus());
471 public void Test6_deleteFromTable1() throws Exception {
472 JsonDelete jsonDelete = new JsonDelete();
473 Map<String, String> consistencyInfo = new HashMap<>();
474 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
475 consistencyInfo.put("type", "atomic");
476 jsonDelete.setConsistencyInfo(consistencyInfo);
477 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
478 Mockito.when(info.getQueryParameters()).thenReturn(row);
479 Response response = data.deleteFromTable("1", "1", "1",
480 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
481 jsonDelete, keyspaceName, tableName, info);
482 assertEquals(400, response.getStatus());
487 public void Test6_deleteFromTable2() throws Exception {
488 JsonDelete jsonDelete = new JsonDelete();
489 Map<String, String> consistencyInfo = new HashMap<>();
490 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
491 row.add("emp_name", "test1");
492 consistencyInfo.put("type", "atomic");
493 jsonDelete.setConsistencyInfo(consistencyInfo);
494 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
495 Mockito.when(info.getQueryParameters()).thenReturn(row);
496 Response response = data.deleteFromTable("1", "1", "1",
497 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
498 null, keyspaceName, tableName, info);
499 assertEquals(400, response.getStatus());
503 public void Test7_dropTable() throws Exception {
504 JsonTable jsonTable = new JsonTable();
505 Map<String, String> consistencyInfo = new HashMap<>();
506 consistencyInfo.put("type", "atomic");
507 jsonTable.setConsistencyInfo(consistencyInfo);
508 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
509 Response response = data.dropTable("1", "1", "1",
510 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
511 keyspaceName, tableName);
512 assertEquals(200, response.getStatus());
516 public void Test8_deleteKeyspace() throws Exception {
517 JsonKeySpace jsonKeyspace = new JsonKeySpace();
518 Map<String, String> consistencyInfo = new HashMap<>();
519 Map<String, Object> replicationInfo = new HashMap<>();
520 consistencyInfo.put("type", "eventual");
521 replicationInfo.put("class", "SimpleStrategy");
522 replicationInfo.put("replication_factor", 1);
523 jsonKeyspace.setConsistencyInfo(consistencyInfo);
524 jsonKeyspace.setDurabilityOfWrites("true");
525 jsonKeyspace.setKeyspaceName("TestApp1");
526 jsonKeyspace.setReplicationInfo(replicationInfo);
527 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
528 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
529 appName, userId, password, keyspaceName);
530 assertEquals(200, response.getStatus());
534 public void Test8_deleteKeyspace2() throws Exception {
535 JsonKeySpace jsonKeyspace = new JsonKeySpace();
536 Map<String, String> consistencyInfo = new HashMap<>();
537 Map<String, Object> replicationInfo = new HashMap<>();
538 consistencyInfo.put("type", "eventual");
539 replicationInfo.put("class", "SimpleStrategy");
540 replicationInfo.put("replication_factor", 1);
541 jsonKeyspace.setConsistencyInfo(consistencyInfo);
542 jsonKeyspace.setDurabilityOfWrites("true");
543 jsonKeyspace.setKeyspaceName("TestApp1");
544 jsonKeyspace.setReplicationInfo(replicationInfo);
545 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
546 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
547 appName, userId, "wrong", keyspaceName);
548 assertEquals(401, response.getStatus());
552 public void Test8_deleteKeyspace3() throws Exception {
553 JsonKeySpace jsonKeyspace = new JsonKeySpace();
554 Map<String, String> consistencyInfo = new HashMap<>();
555 Map<String, Object> replicationInfo = new HashMap<>();
556 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
557 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
558 appName, userId, password, keyspaceName);
559 assertEquals(400, response.getStatus());
565 public void Test6_onboard() throws Exception {
566 JsonOnboard jsonOnboard = new JsonOnboard();
567 jsonOnboard.setAppname("TestApp2");
568 jsonOnboard.setIsAAF("false");
569 jsonOnboard.setUserId("TestUser2");
570 jsonOnboard.setPassword("TestPassword2");
571 Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
572 resultMap.containsKey("success");
573 onboardUUID = resultMap.get("Generated AID").toString();
574 assertEquals("Your application TestApp2 has been onboarded with MUSIC.", resultMap.get("Success"));
578 public void Test6_onboard1() throws Exception {
579 JsonOnboard jsonOnboard = new JsonOnboard();
580 jsonOnboard.setIsAAF("false");
581 jsonOnboard.setUserId("TestUser2");
582 jsonOnboard.setPassword("TestPassword2");
583 Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
584 resultMap.containsKey("success");
585 System.out.println("--->" + resultMap.toString());
586 assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
591 public void Test7_onboardSearch() throws Exception {
592 JsonOnboard jsonOnboard = new JsonOnboard();
593 jsonOnboard.setAppname("TestApp2");
594 jsonOnboard.setIsAAF("false");
595 jsonOnboard.setAid(onboardUUID);
596 Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
597 resultMap.containsKey("success");
598 assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
604 public void Test7_onboardSearch1() throws Exception {
605 JsonOnboard jsonOnboard = new JsonOnboard();
606 jsonOnboard.setIsAAF("false");
607 jsonOnboard.setAid(onboardUUID);
608 Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
609 System.out.println("--->" + resultMap.toString());
610 resultMap.containsKey("success");
611 assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
616 public void Test8_onboardUpdate() throws Exception {
617 JsonOnboard jsonOnboard = new JsonOnboard();
618 jsonOnboard.setIsAAF("false");
619 jsonOnboard.setUserId("TestUser3");
620 jsonOnboard.setPassword("TestPassword3");
621 jsonOnboard.setAid(onboardUUID);
622 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
623 System.out.println("--->" + resultMap.toString());
624 resultMap.containsKey("success");
625 assertEquals("Your application has been updated successfully", resultMap.get("Success"));
630 public void Test8_onboardUpdate1() throws Exception {
631 JsonOnboard jsonOnboard = new JsonOnboard();
632 jsonOnboard.setIsAAF("false");
633 jsonOnboard.setUserId("TestUser3");
634 jsonOnboard.setPassword("TestPassword3");
635 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
636 System.out.println("--->" + resultMap.toString());
637 resultMap.containsKey("success");
638 assertEquals("Please make sure Aid is present", resultMap.get("Exception"));
643 public void Test8_onboardUpdate2() throws Exception {
644 JsonOnboard jsonOnboard = new JsonOnboard();
645 jsonOnboard.setAppname("TestApp2");
646 jsonOnboard.setIsAAF("false");
647 jsonOnboard.setUserId("TestUser3");
648 jsonOnboard.setPassword("TestPassword3");
649 jsonOnboard.setAid(onboardUUID);
650 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
651 resultMap.containsKey("success");
652 System.out.println("--->" + resultMap.toString());
653 assertEquals("Application TestApp2 has already been onboarded. Please contact admin.", resultMap.get("Exception"));
658 public void Test8_onboardUpdate3() throws Exception {
659 JsonOnboard jsonOnboard = new JsonOnboard();
660 jsonOnboard.setAid(onboardUUID);
661 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
662 assertTrue(resultMap.containsKey("Exception") );
666 public void Test9_onboardDelete() throws Exception {
667 JsonOnboard jsonOnboard = new JsonOnboard();
668 jsonOnboard.setAppname("TestApp2");
669 jsonOnboard.setAid(onboardUUID);
670 Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
671 resultMap.containsKey("success");
672 assertEquals("Your application has been deleted successfully", resultMap.get("Success"));
676 public void Test9_onboardDelete1() throws Exception {
677 JsonOnboard jsonOnboard = new JsonOnboard();
678 Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
679 assertTrue(resultMap.containsKey("Exception"));
683 public void Test3_createLockReference() throws Exception {
684 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
685 Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1", null, appName, userId, password).getEntity();
686 @SuppressWarnings("unchecked")
687 Map<String, Object> resultMap1 = (Map<String, Object>) resultMap.get("lock");
688 lockId = (String) resultMap1.get("lock");
689 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
693 public void Test4_accquireLock() throws Exception {
694 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
695 Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLock(lockId,"1","1", null, appName, userId, password).getEntity();
696 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
700 public void Test5_currentLockHolder() throws Exception {
701 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
702 Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder(lockName,"1","1", null, appName, userId, password).getEntity();
703 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
707 public void Test7_unLock() throws Exception {
708 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
709 Map<String, Object> resultMap = (Map<String, Object>) lock.unLock(lockId,"1","1", null, appName, userId, password).getEntity();
710 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
714 public void Test8_delete() throws Exception {
715 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
716 Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null, appName, userId, password).getEntity();
717 assertEquals(ResultType.SUCCESS, resultMap.get("status"));