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         //row.add("emp_name", "test1");
 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 //        consistencyInfo.put("type", "eventual");
 556 //        replicationInfo.put("class", "SimpleStrategy");
 557 //        replicationInfo.put("replication_factor", 1);
 558 //        jsonKeyspace.setConsistencyInfo(consistencyInfo);
 559 //        jsonKeyspace.setDurabilityOfWrites("true");
 560  //       jsonKeyspace.setKeyspaceName("TestApp1");
 561 //        jsonKeyspace.setReplicationInfo(replicationInfo);
 562         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 563         Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
 564                 appName, userId, password, keyspaceName);
 565         assertEquals(400, response.getStatus());
 566     }
 567
 568
 569
 570     @Test
 571     public void Test6_onboard() throws Exception {
 572         JsonOnboard jsonOnboard = new JsonOnboard();
 573         jsonOnboard.setAppname("TestApp2");
 574         jsonOnboard.setIsAAF("false");
 575         jsonOnboard.setUserId("TestUser2");
 576         jsonOnboard.setPassword("TestPassword2");
 577         Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
 578         resultMap.containsKey("success");
 579         onboardUUID = resultMap.get("Generated AID").toString();
 580         assertEquals("Your application TestApp2 has been onboarded with MUSIC.", resultMap.get("Success"));
 581     }
 582     // Missing appname
 583     @Test
 584     public void Test6_onboard1() throws Exception {
 585         JsonOnboard jsonOnboard = new JsonOnboard();
 586 //        jsonOnboard.setAppname("TestApp2");
 587         jsonOnboard.setIsAAF("false");
 588         jsonOnboard.setUserId("TestUser2");
 589         jsonOnboard.setPassword("TestPassword2");
 590         Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard).getEntity();
 591         resultMap.containsKey("success");
 592         System.out.println("--->" + resultMap.toString());
 593 //        onboardUUID = resultMap.get("Generated AID").toString();
 594         assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
 595     }
 596
 597
 598     @Test
 599     public void Test7_onboardSearch() throws Exception {
 600         JsonOnboard jsonOnboard = new JsonOnboard();
 601         jsonOnboard.setAppname("TestApp2");
 602         jsonOnboard.setIsAAF("false");
 603         jsonOnboard.setAid(onboardUUID);
 604         Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
 605         resultMap.containsKey("success");
 606         assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
 607
 608     }
 609
 610     // Missing appname
 611     @Test
 612     public void Test7_onboardSearch1() throws Exception {
 613         JsonOnboard jsonOnboard = new JsonOnboard();
 614 //        jsonOnboard.setAppname("TestApp2");
 615         jsonOnboard.setIsAAF("false");
 616         jsonOnboard.setAid(onboardUUID);
 617         Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
 618         System.out.println("--->" + resultMap.toString());
 619         resultMap.containsKey("success");
 620         assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
 621
 622     }
 623
 624     @Test
 625     public void Test8_onboardUpdate() throws Exception {
 626         JsonOnboard jsonOnboard = new JsonOnboard();
 627         jsonOnboard.setIsAAF("false");
 628         jsonOnboard.setUserId("TestUser3");
 629         jsonOnboard.setPassword("TestPassword3");
 630         jsonOnboard.setAid(onboardUUID);
 631         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
 632         System.out.println("--->" + resultMap.toString());
 633         resultMap.containsKey("success");
 634         assertEquals("Your application has been updated successfully", resultMap.get("Success"));
 635     }
 636
 637     // Aid null
 638     @Test
 639     public void Test8_onboardUpdate1() throws Exception {
 640         JsonOnboard jsonOnboard = new JsonOnboard();
 641         jsonOnboard.setIsAAF("false");
 642         jsonOnboard.setUserId("TestUser3");
 643         jsonOnboard.setPassword("TestPassword3");
 644 //        jsonOnboard.setAid(onboardUUID);
 645         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
 646         System.out.println("--->" + resultMap.toString());
 647         resultMap.containsKey("success");
 648         assertEquals("Please make sure Aid is present", resultMap.get("Exception"));
 649     }
 650
 651     // Appname not null
 652     @Test
 653     public void Test8_onboardUpdate2() throws Exception {
 654         JsonOnboard jsonOnboard = new JsonOnboard();
 655         jsonOnboard.setAppname("TestApp2");
 656         jsonOnboard.setIsAAF("false");
 657         jsonOnboard.setUserId("TestUser3");
 658         jsonOnboard.setPassword("TestPassword3");
 659         jsonOnboard.setAid(onboardUUID);
 660         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
 661         resultMap.containsKey("success");
 662         System.out.println("--->" + resultMap.toString());
 663         assertEquals("Application TestApp2 has already been onboarded. Please contact admin.", resultMap.get("Exception"));
 664     }
 665
 666     // All null
 667     @Test
 668     public void Test8_onboardUpdate3() throws Exception {
 669         JsonOnboard jsonOnboard = new JsonOnboard();
 670 //        jsonOnboard.setAppname("TestApp2");
 671 //        jsonOnboard.setIsAAF("false");
 672 //        jsonOnboard.setUserId("TestUser3");
 673 //        jsonOnboard.setPassword("TestPassword3");
 674         jsonOnboard.setAid(onboardUUID);
 675         Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard).getEntity();
 676         assertTrue(resultMap.containsKey("Exception") );
 677     }
 678
 679     @Test
 680     public void Test9_onboardDelete() throws Exception {
 681         JsonOnboard jsonOnboard = new JsonOnboard();
 682         jsonOnboard.setAppname("TestApp2");
 683         jsonOnboard.setAid(onboardUUID);
 684         Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
 685         resultMap.containsKey("success");
 686         assertEquals("Your application has been deleted successfully", resultMap.get("Success"));
 687     }
 688
 689     @Test
 690     public void Test9_onboardDelete1() throws Exception {
 691         JsonOnboard jsonOnboard = new JsonOnboard();
 692 //        jsonOnboard.setAppname("TestApp2");
 693 //        jsonOnboard.setAid(onboardUUID);
 694         Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard).getEntity();
 695         assertTrue(resultMap.containsKey("Exception"));
 696     }
 697
 698     @Test
 699     public void Test3_createLockReference() throws Exception {
 700         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 701         Map<String, Object> resultMap = lock.createLockReference(lockName, null, appName, userId, password, http);
 702         @SuppressWarnings("unchecked")
 703         Map<String, Object> resultMap1 = (Map<String, Object>) resultMap.get("lock");
 704         lockId = (String) resultMap1.get("lock");
 705         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
 706     }
 707
 708     @Test
 709     public void Test4_accquireLock() throws Exception {
 710         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 711         Map<String, Object> resultMap = lock.accquireLock(lockId, null, appName, userId, password, http);
 712         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
 713     }
 714
 715     @Test
 716     public void Test5_currentLockHolder() throws Exception {
 717         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 718         Map<String, Object> resultMap = lock.currentLockHolder(lockName, null, appName, userId, password, http);
 719         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
 720     }
 721
 722     @Test
 723     public void Test7_unLock() throws Exception {
 724         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 725         Map<String, Object> resultMap = lock.unLock(lockId, null, appName, userId, password, http);
 726         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
 727     }
 728
 729     @Test
 730     public void Test8_delete() throws Exception {
 731         Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
 732         Map<String, Object> resultMap = lock.deleteLock(lockName, null, appName, userId, password, http);
 733         assertEquals(ResultType.SUCCESS, resultMap.get("status"));
 734     }
 735 }