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