jar/src/test/java/org/onap/music/unittests/TestRestMusicData.java

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