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
  19 package org.onap.music.unittests;
  20
  21 import static org.junit.Assert.assertEquals;
  22 import static org.junit.Assert.assertFalse;
  23 import static org.junit.Assert.assertTrue;
  24 import java.io.File;
  25 import java.util.HashMap;
  26 import java.util.List;
  27 import java.util.Map;
  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;
  63
  64 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
  65 @RunWith(MockitoJUnitRunner.class)
  66 public class TestRestMusicData {
  67
  68     RestMusicDataAPI data = new RestMusicDataAPI();
  69     RestMusicAdminAPI admin = new RestMusicAdminAPI();
  70     RestMusicLocksAPI lock = new RestMusicLocksAPI();
  71     static PreparedQueryObject testObject;
  72     static TestingServer zkServer;
  73
  74     @Mock
  75     HttpServletResponse http;
  76
  77     @Mock
  78     UriInfo info;
  79
  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";
  91
  92     @BeforeClass
  93     public static void init() throws Exception {
  94         try {
  95             MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
  96             zkServer = new TestingServer(2181, new File("/tmp/zk"));
  97             MusicCore.mLockHandle = new MusicLockingService();
  98         } catch (Exception e) {
  99             e.printStackTrace();
 100         }
 101     }
 102
 103     @AfterClass
 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();
 115         zkServer.stop();
 116     }
 117
 118     @Test
 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);
 132
 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);
 146
 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);
 161
 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"));
 170         }
 171     }
 172
 173     @Test
 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());
 191     }
 192
 193     @Test
 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());
 204     }
 205 //MusicCore.autheticateUser
 206     @Test
 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());
 218     }
 219
 220     @Test
 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());
 238     }
 239
 240     @Test
 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());
 262     }
 263
 264     // Improper Auth
 265     @Test
 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());
 287     }
 288
 289     // Improper keyspace
 290     @Test
 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());
 312     }
 313
 314
 315
 316     @Test
 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());
 333     }
 334
 335     @Test
 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());
 353     }
 354
 355     // Auth Error
 356     @Test
 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());
 374     }
 375
 376     // Table wrong
 377     @Test
 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());
 395     }
 396
 397
 398
 399     @Test
 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());
 417     }
 418
 419     @Test
 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());
 434     }
 435
 436     @Test
 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());
 451     }
 452
 453     @Test
 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());
 467     }
 468
 469     // Values
 470     @Test
 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());
 483     }
 484
 485     // delObj
 486     @Test
 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());
 500     }
 501
 502     @Test
 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());
 513     }
 514
 515     @Test
 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());
 531     }
 532
 533     @Test
 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());
 549     }
 550
 551     @Test
 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());
 560     }
 561
 562
 563
 564     @Test
 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"));
 575     }
 576     // Missing appname
 577     @Test
 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"));
 587     }
 588
 589
 590     @Test
 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));
 599
 600     }
 601
 602     // Missing appname
 603     @Test
 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));
 612
 613     }
 614
 615     @Test
 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"));
 626     }
 627
 628     // Aid null
 629     @Test
 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"));
 639     }
 640
 641     // Appname not null
 642     @Test
 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"));
 654     }
 655
 656     // All null
 657     @Test
 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") );
 663     }
 664
 665     @Test
 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"));
 673     }
 674
 675     @Test
 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"));
 680     }
 681
 682     @Test
 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"));
 690     }
 691
 692     @Test
 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"));
 697     }
 698
 699     @Test
 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"));
 704     }
 705
 706     @Test
 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"));
 711     }
 712
 713     @Test
 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"));
 718     }
 719 }