2 * ============LICENSE_START========================================== org.onap.music
3 * =================================================================== Copyright (c) 2017 AT&T
4 * Intellectual Property ===================================================================
5 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
6 * in compliance with the License. You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software distributed under the License
11 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12 * or implied. See the License for the specific language governing permissions and limitations under
15 * ============LICENSE_END=============================================
16 * ====================================================================
19 package org.onap.music.unittests;
21 import static org.junit.Assert.assertEquals;
22 import static org.junit.Assert.assertFalse;
23 import static org.junit.Assert.assertNotEquals;
24 import static org.junit.Assert.assertNotNull;
25 import static org.junit.Assert.assertTrue;
26 //import static org.onap.music.main.MusicCore.mLockHandle;
29 import java.util.ArrayList;
30 import java.util.HashMap;
31 import java.util.List;
33 import java.util.UUID;
35 import javax.servlet.http.HttpServletResponse;
36 import javax.ws.rs.core.MultivaluedMap;
37 import javax.ws.rs.core.Response;
38 import javax.ws.rs.core.UriInfo;
40 import org.apache.curator.test.TestingServer;
41 import org.junit.AfterClass;
42 import org.junit.BeforeClass;
43 import org.junit.FixMethodOrder;
44 import org.junit.Ignore;
45 import org.junit.Test;
46 import org.junit.runner.RunWith;
47 import org.junit.runners.MethodSorters;
48 import org.mindrot.jbcrypt.BCrypt;
49 import org.mockito.InjectMocks;
50 import org.mockito.Mock;
51 import org.mockito.Mockito;
52 import org.mockito.MockitoAnnotations;
53 import org.mockito.runners.MockitoJUnitRunner;
54 import org.onap.music.conductor.conditionals.JsonConditional;
55 import org.onap.music.conductor.conditionals.RestMusicConditionalAPI;
56 import org.onap.music.datastore.MusicDataStoreHandle;
57 import org.onap.music.datastore.PreparedQueryObject;
58 import org.onap.music.datastore.jsonobjects.JsonDelete;
59 import org.onap.music.datastore.jsonobjects.JsonInsert;
60 import org.onap.music.datastore.jsonobjects.JsonKeySpace;
61 import org.onap.music.datastore.jsonobjects.JsonLeasedLock;
62 import org.onap.music.datastore.jsonobjects.JsonOnboard;
63 import org.onap.music.datastore.jsonobjects.JsonSelect;
64 import org.onap.music.datastore.jsonobjects.JsonTable;
65 import org.onap.music.datastore.jsonobjects.JsonUpdate;
66 import org.onap.music.exceptions.MusicServiceException;
67 import org.onap.music.lockingservice.zookeeper.MusicLockingService;
68 import org.onap.music.main.MusicCore;
69 import org.onap.music.main.MusicUtil;
70 import org.onap.music.main.ResultType;
71 import org.onap.music.rest.RestMusicAdminAPI;
72 import org.onap.music.rest.RestMusicBmAPI;
73 import org.onap.music.rest.RestMusicDataAPI;
74 import org.onap.music.rest.RestMusicHealthCheckAPI;
75 import org.onap.music.rest.RestMusicLocksAPI;
76 import org.onap.music.rest.RestMusicTestAPI;
77 import org.onap.music.rest.RestMusicVersionAPI;
78 import org.onap.music.service.impl.MusicZKCore;
79 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
81 import com.datastax.driver.core.DataType;
82 import com.datastax.driver.core.ResultSet;
83 import com.datastax.driver.core.Row;
84 import com.sun.jersey.core.util.Base64;
85 import com.sun.jersey.core.util.MultivaluedMapImpl;
87 @FixMethodOrder(MethodSorters.NAME_ASCENDING)
88 @RunWith(SpringJUnit4ClassRunner.class)
89 public class TestRestAdminData {
91 RestMusicDataAPI data = new RestMusicDataAPI();
92 RestMusicAdminAPI admin = new RestMusicAdminAPI();
93 RestMusicLocksAPI lock = new RestMusicLocksAPI();
94 static PreparedQueryObject testObject;
95 static TestingServer zkServer;
98 HttpServletResponse http;
107 private MusicCore mCore;
109 static MusicLockingService mLockHandle;
112 static String appName = "TestApp";
113 static String userId = "TestUser";
114 static String password = "TestPassword";
115 static String adminName = "username";
116 static String adminPassword = "password";
117 static String adminAuthData = adminName +":"+adminPassword;
118 static String wrongAdminAuthData = adminName+"123"+":"+adminPassword;
119 static String authData = userId+":"+password;
120 static String wrongAuthData = userId+":"+"pass";
121 static String authorization = new String(Base64.encode(authData.getBytes()));
122 static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
123 static String adminAuthorization = new String(Base64.encode(adminAuthData.getBytes()));
124 static String worngAdminAuthorization = new String(Base64.encode(wrongAdminAuthData.getBytes()));
126 static boolean isAAF = false;
127 static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
128 static String keyspaceName = "testCassa";
129 static String tableName = "employees";
130 static String tableNameConditional = "Conductor";
131 static String xLatestVersion = "X-latestVersion";
132 static String onboardUUID = null;
133 static String lockId = null;
134 static String lockName = "testCassa.employees.sample3";
137 public static void init() throws Exception {
139 MusicDataStoreHandle.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
140 zkServer = new TestingServer(2181, new File("/tmp/zk"));
141 mLockHandle = MusicZKCore.getLockingServiceHandle();
142 } catch (Exception e) {
148 public static void tearDownAfterClass() throws Exception {
149 testObject = new PreparedQueryObject();
150 testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
151 MusicCore.eventualPut(testObject);
152 testObject = new PreparedQueryObject();
153 testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
154 MusicCore.eventualPut(testObject);
155 MusicDataStoreHandle.mDstoreHandle.close();
161 public void Test1_createKeyspace() throws Exception {
162 testObject = new PreparedQueryObject();
163 testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = "
164 + "{'class' : 'SimpleStrategy' , "
165 + "'replication_factor': 1} AND DURABLE_WRITES = true");
166 MusicCore.eventualPut(testObject);
167 testObject = new PreparedQueryObject();
168 testObject.appendQueryString(
169 "CREATE TABLE admin.keyspace_master (" + " uuid uuid, keyspace_name text,"
170 + " application_name text, is_api boolean,"
171 + " password text, username text,"
172 + " is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
173 MusicCore.eventualPut(testObject);
175 testObject = new PreparedQueryObject();
176 testObject.appendQueryString(
177 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
178 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
179 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
180 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
181 MusicUtil.DEFAULTKEYSPACENAME));
182 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
183 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
184 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
185 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
186 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
187 MusicCore.eventualPut(testObject);
189 testObject = new PreparedQueryObject();
190 testObject.appendQueryString(
191 "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
192 + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
193 testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
194 UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
195 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
196 MusicUtil.DEFAULTKEYSPACENAME));
197 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
198 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
199 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
200 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
201 testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
202 MusicCore.eventualPut(testObject);
204 testObject = new PreparedQueryObject();
205 testObject.appendQueryString(
206 "select uuid from admin.keyspace_master where application_name = ? allow filtering");
207 testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
208 ResultSet rs = MusicCore.get(testObject);
209 List<Row> rows = rs.all();
210 if (rows.size() > 0) {
211 System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
213 PreparedQueryObject pQuery = new PreparedQueryObject();
214 String consistency = MusicUtil.EVENTUAL;
215 pQuery.appendQueryString("CREATE TABLE IF NOT EXISTS admin.locks ( lock_id text PRIMARY KEY, ctime text)");
217 ResultType result = MusicCore.nonKeyRelatedPut(pQuery, consistency);
218 } catch (MusicServiceException e1) {
219 e1.printStackTrace();
224 public void Test2_createKeyspace() throws Exception {
225 JsonKeySpace jsonKeyspace = new JsonKeySpace();
226 Map<String, String> consistencyInfo = new HashMap<>();
227 Map<String, Object> replicationInfo = new HashMap<>();
228 consistencyInfo.put("type", "eventual");
229 replicationInfo.put("class", "SimpleStrategy");
230 replicationInfo.put("replication_factor", 1);
231 jsonKeyspace.setConsistencyInfo(consistencyInfo);
232 jsonKeyspace.setDurabilityOfWrites("true");
233 jsonKeyspace.setKeyspaceName(keyspaceName);
234 jsonKeyspace.setReplicationInfo(replicationInfo);
235 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
236 Response response = data.createKeySpace("1", "1", "1", null,authorization, appName, jsonKeyspace, keyspaceName);
237 System.out.println("#######status is " + response.getStatus());
238 System.out.println("Entity" + response.getEntity());
239 //assertEquals(200,response.getStatus());
240 assertEquals(400,response.getStatus());
244 public void Test2_createKeyspace_wrongConsistency() throws Exception {
245 JsonKeySpace jsonKeyspace = new JsonKeySpace();
246 Map<String, String> consistencyInfo = new HashMap<>();
247 Map<String, Object> replicationInfo = new HashMap<>();
248 consistencyInfo.put("type", "eventual123");
249 replicationInfo.put("class", "SimpleStrategy");
250 replicationInfo.put("replication_factor", 1);
251 jsonKeyspace.setConsistencyInfo(consistencyInfo);
252 jsonKeyspace.setDurabilityOfWrites("true");
253 jsonKeyspace.setKeyspaceName(keyspaceName);
254 jsonKeyspace.setReplicationInfo(replicationInfo);
255 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
256 Response response = data.createKeySpace("1", "1", "1", null,authorization, appName, jsonKeyspace, keyspaceName);
257 System.out.println("#######status is " + response.getStatus());
258 System.out.println("Entity" + response.getEntity());
259 assertEquals(400,response.getStatus());
263 public void Test2_createKeyspace1() throws Exception {
264 JsonKeySpace jsonKeyspace = new JsonKeySpace();
265 Map<String, String> consistencyInfo = new HashMap<>();
266 Map<String, Object> replicationInfo = new HashMap<>();
267 consistencyInfo.put("type", "eventual");
268 replicationInfo.put("class", "SimpleStrategy");
269 replicationInfo.put("replication_factor", 1);
270 jsonKeyspace.setConsistencyInfo(consistencyInfo);
271 jsonKeyspace.setDurabilityOfWrites("true");
272 jsonKeyspace.setKeyspaceName(keyspaceName);
273 jsonKeyspace.setReplicationInfo(replicationInfo);
274 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
275 Response response = data.createKeySpace("1", "1", "1", null,authorization, appName, jsonKeyspace, "keyspaceName");
276 System.out.println("#######status is " + response.getStatus());
277 System.out.println("Entity" + response.getEntity());
278 //assertEquals(200,response.getStatus());
279 assertEquals(400,response.getStatus());
283 public void Test2_createKeyspace0() throws Exception {
284 JsonKeySpace jsonKeyspace = new JsonKeySpace();
285 Map<String, String> consistencyInfo = new HashMap<>();
286 Map<String, Object> replicationInfo = new HashMap<>();
287 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
288 Response response = data.createKeySpace("1", "1", "1", null, authorization,appName, jsonKeyspace, keyspaceName);
289 System.out.println("#######status is " + response.getStatus());
290 System.out.println("Entity" + response.getEntity());
291 assertEquals(400,response.getStatus());
293 //MusicCore.autheticateUser
295 public void Test2_createKeyspace01() throws Exception {
296 JsonKeySpace jsonKeyspace = new JsonKeySpace();
297 Map<String, String> consistencyInfo = new HashMap<>();
298 Map<String, Object> replicationInfo = new HashMap<>();
299 String appName1 = "test";
300 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
301 Response response = data.createKeySpace("1", "1", "1", null,authorization, appName1, jsonKeyspace, keyspaceName);
302 System.out.println("#######status is " + response.getStatus());
303 System.out.println("Entity" + response.getEntity());
304 //assertEquals(401,response.getStatus());
305 assertEquals(400,response.getStatus());
309 public void Test3_createKeyspace1() throws Exception {
310 JsonKeySpace jsonKeyspace = new JsonKeySpace();
311 Map<String, String> consistencyInfo = new HashMap<>();
312 Map<String, Object> replicationInfo = new HashMap<>();
313 consistencyInfo.put("type", "eventual");
314 replicationInfo.put("class", "SimpleStrategy");
315 replicationInfo.put("replication_factor", 1);
316 jsonKeyspace.setConsistencyInfo(consistencyInfo);
317 jsonKeyspace.setDurabilityOfWrites("true");
318 jsonKeyspace.setKeyspaceName("TestApp1");
319 jsonKeyspace.setReplicationInfo(replicationInfo);
320 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
321 Response response = data.createKeySpace("1", "1", "1", null,authorization, "TestApp1",
322 jsonKeyspace, keyspaceName);
323 System.out.println("#######status is " + response.getStatus());
324 System.out.println("Entity" + response.getEntity());
325 //assertEquals(401,response.getStatus());
326 assertEquals(400,response.getStatus());
330 public void Test2_createKeyspaceEmptyAuth() throws Exception {
332 //MockitoAnnotations.initMocks(this);
333 JsonKeySpace jsonKeyspace = new JsonKeySpace();
334 Map<String, String> consistencyInfo = new HashMap<>();
335 Map<String, Object> replicationInfo = new HashMap<>();
336 consistencyInfo.put("type", "eventual");
337 replicationInfo.put("class", "SimpleStrategy");
338 replicationInfo.put("replication_factor", 1);
339 jsonKeyspace.setConsistencyInfo(consistencyInfo);
340 jsonKeyspace.setDurabilityOfWrites("true");
341 jsonKeyspace.setKeyspaceName(keyspaceName);
342 jsonKeyspace.setReplicationInfo(replicationInfo);
343 //Map<String, Object> m1= new HashMap<>() ;
344 //Mockito.when(CachingUtil.verifyOnboarding("x","y","x")).thenReturn(m1);
345 //Mockito.when(CachingUtil.verifyOnboarding(appNamex,userId,password).thenReturn(m1));
346 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
347 String authDatax = ":"+password;
348 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
350 Response response = data.createKeySpace("1", "1", "1", null,authorizationx, appName, jsonKeyspace, keyspaceName);
351 //System.out.println("#######status is " + response.getStatus());
352 //System.out.println("Entity" + response.getEntity());
353 //assertNotEquals(200,response.getStatus());
354 } catch (RuntimeException e ) {
355 System.out.println("#######status is runtime exception= " + e);
360 public void Test3_createTable() throws Exception {
361 JsonTable jsonTable = new JsonTable();
362 Map<String, String> consistencyInfo = new HashMap<>();
363 Map<String, String> fields = new HashMap<>();
364 fields.put("uuid", "text");
365 fields.put("emp_name", "text");
366 fields.put("emp_salary", "varint");
367 fields.put("PRIMARY KEY", "(emp_name)");
368 consistencyInfo.put("type", "eventual");
369 jsonTable.setConsistencyInfo(consistencyInfo);
370 jsonTable.setKeyspaceName(keyspaceName);
371 jsonTable.setPrimaryKey("emp_name");
372 jsonTable.setTableName(tableName);
373 jsonTable.setFields(fields);
374 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
375 Response response = data.createTable("1", "1", "1",
376 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
377 jsonTable, keyspaceName, tableName);
378 System.out.println("#######status is " + response.getStatus());
379 System.out.println("Entity" + response.getEntity());
380 //assertEquals(200, response.getStatus());
381 assertEquals(401, response.getStatus());
385 public void Test3_createTable_wrongKeyspace() throws Exception {
386 JsonTable jsonTable = new JsonTable();
387 Map<String, String> consistencyInfo = new HashMap<>();
388 Map<String, String> fields = new HashMap<>();
389 fields.put("uuid", "text");
390 fields.put("emp_name", "text");
391 fields.put("emp_salary", "varint");
392 fields.put("PRIMARY KEY", "(emp_name)");
393 consistencyInfo.put("type", "eventual");
394 jsonTable.setConsistencyInfo(consistencyInfo);
395 jsonTable.setKeyspaceName("keyspaceName12");
396 jsonTable.setPrimaryKey("emp_name");
397 jsonTable.setTableName(tableName);
398 jsonTable.setFields(fields);
399 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
400 Response response = data.createTable("1", "1", "1",
401 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
402 jsonTable, keyspaceName, tableName);
403 System.out.println("#######status is " + response.getStatus());
404 System.out.println("Entity" + response.getEntity());
405 //assertEquals(400, response.getStatus());
406 assertEquals(401, response.getStatus());
410 public void Test3_createTableClusterOrderBad() throws Exception {
411 JsonTable jsonTable = new JsonTable();
412 Map<String, String> consistencyInfo = new HashMap<>();
413 Map<String, String> fields = new HashMap<>();
414 fields.put("uuid", "text");
415 fields.put("emp_name", "text");
416 fields.put("emp_salary", "varint");
417 fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
418 consistencyInfo.put("type", "eventual");
419 jsonTable.setConsistencyInfo(consistencyInfo);
420 jsonTable.setKeyspaceName(keyspaceName);
421 jsonTable.setPrimaryKey("emp_name,emp_salary");
422 jsonTable.setClusteringOrder("ASC");
423 jsonTable.setTableName(tableName);
424 jsonTable.setFields(fields);
425 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
426 Response response = data.createTable("1", "1", "1",
427 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
428 jsonTable, keyspaceName, tableName);
429 System.out.println("#######status is " + response.getStatus());
430 System.out.println("Entity" + response.getEntity());
431 assertNotEquals(200, response.getStatus());
435 public void Test3_createTable_withPropertiesNotNull() throws Exception {
436 JsonTable jsonTable = new JsonTable();
437 Map<String, String> consistencyInfo = new HashMap<>();
438 Map<String, String> fields = new HashMap<>();
439 fields.put("uuid", "text");
440 fields.put("emp_name", "text");
441 fields.put("emp_salary", "varint");
442 fields.put("PRIMARY KEY", "(emp_name)");
443 consistencyInfo.put("type", "eventual");
444 Map<String, Object> properties = new HashMap<>();
445 properties.put("comment","Testing prperties not null");
446 jsonTable.setConsistencyInfo(consistencyInfo);
447 jsonTable.setKeyspaceName(keyspaceName);
448 jsonTable.setPrimaryKey("emp_name");
449 String tableName_prop=tableName+"_Prop";
450 jsonTable.setTableName(tableName_prop);
451 jsonTable.setFields(fields);
452 jsonTable.setProperties(properties);
454 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
455 Response response = data.createTable("1", "1", "1",
456 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
457 jsonTable, keyspaceName, tableName_prop);
458 System.out.println("#######status is " + response.getStatus());
459 System.out.println("Entity" + response.getEntity());
460 //assertEquals(200, response.getStatus());
461 assertEquals(401, response.getStatus());
465 public void Test3_createTable_duplicateTable() throws Exception {
466 JsonTable jsonTable = new JsonTable();
467 Map<String, String> consistencyInfo = new HashMap<>();
468 Map<String, String> fields = new HashMap<>();
469 fields.put("uuid", "text");
470 fields.put("emp_name", "text");
471 fields.put("emp_salary", "varint");
472 fields.put("PRIMARY KEY", "(emp_name)");
473 consistencyInfo.put("type", "eventual");
474 jsonTable.setConsistencyInfo(consistencyInfo);
475 jsonTable.setKeyspaceName(keyspaceName);
476 jsonTable.setPrimaryKey("emp_name");
477 String tableNameDup=tableName+"X";
478 jsonTable.setTableName(tableNameDup);
479 jsonTable.setFields(fields);
480 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
481 Response response = data.createTable("1", "1", "1",
482 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
483 jsonTable, keyspaceName, tableNameDup);
484 System.out.println("#######status for 1st time " + response.getStatus());
485 System.out.println("Entity" + response.getEntity());
487 Response response0 = data.createTable("1", "1", "1",
488 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
489 jsonTable, keyspaceName, tableNameDup);
490 // 400 is the duplicate status found in response
491 // Music 113 duplicate testing
492 //import static org.junit.Assert.assertNotEquals;
493 System.out.println("#######status for 2nd time " + response0.getStatus());
494 System.out.println("Entity" + response0.getEntity());
496 assertFalse("Duplicate table not created for "+tableNameDup, 200==response0.getStatus());
502 public void Test3_createTable1() throws Exception {
503 JsonTable jsonTable = new JsonTable();
504 Map<String, String> consistencyInfo = new HashMap<>();
505 Map<String, String> fields = new HashMap<>();
506 fields.put("uuid", "text");
507 fields.put("emp_name", "text");
508 fields.put("emp_salary", "varint");
509 fields.put("PRIMARY KEY", "(emp_name)");
510 consistencyInfo.put("type", "eventual");
511 jsonTable.setConsistencyInfo(consistencyInfo);
512 jsonTable.setKeyspaceName(keyspaceName);
513 jsonTable.setPrimaryKey("emp_name");
514 jsonTable.setTableName(tableName);
515 jsonTable.setFields(fields);
516 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
517 Response response = data.createTable("1", "1", "1",
518 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
519 jsonTable, keyspaceName, tableName);
520 System.out.println("#######status is " + response.getStatus());
521 System.out.println("Entity" + response.getEntity());
522 assertEquals(401, response.getStatus());
527 public void Test3_createTable3() throws Exception {
528 JsonTable jsonTable = new JsonTable();
529 Map<String, String> consistencyInfo = new HashMap<>();
530 Map<String, String> fields = new HashMap<>();
531 fields.put("uuid", "text");
532 fields.put("emp_name", "text");
533 fields.put("emp_salary", "varint");
534 fields.put("PRIMARY KEY", "(emp_name)");
535 consistencyInfo.put("type", "eventual");
536 jsonTable.setConsistencyInfo(consistencyInfo);
537 jsonTable.setKeyspaceName(keyspaceName);
538 jsonTable.setPrimaryKey("emp_name");
539 jsonTable.setTableName(tableName);
540 jsonTable.setFields(fields);
541 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
542 Response response = data.createTable("1", "1", "1",
543 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
544 jsonTable, "wrong", tableName);
545 System.out.println("#######status is " + response.getStatus());
546 System.out.println("Entity" + response.getEntity());
547 assertEquals(401, response.getStatus());
551 public void Test3_createTable3_with_samePartition_clusteringKeys() throws Exception {
552 JsonTable jsonTable = new JsonTable();
553 Map<String, String> consistencyInfo = new HashMap<>();
554 Map<String, String> fields = new HashMap<>();
555 fields.put("uuid", "text");
556 fields.put("emp_name", "text");
557 fields.put("emp_salary", "varint");
558 fields.put("PRIMARY KEY", "(emp_name, emp_name)");
559 consistencyInfo.put("type", "eventual");
560 jsonTable.setConsistencyInfo(consistencyInfo);
561 jsonTable.setKeyspaceName(keyspaceName);
562 jsonTable.setPartitionKey("emp_name");
563 jsonTable.setClusteringKey("emp_name");
564 jsonTable.setTableName(tableName);
565 jsonTable.setFields(fields);
566 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
567 Response response = data.createTable("1", "1", "1",
568 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
569 jsonTable, keyspaceName, tableName);
570 System.out.println("#######status is " + response.getStatus());
571 System.out.println("Entity" + response.getEntity());
572 assertEquals(401, response.getStatus());
577 public void Test3_createTable3_with_Partition_clusteringKeys() throws Exception {
578 JsonTable jsonTable = new JsonTable();
579 Map<String, String> consistencyInfo = new HashMap<>();
580 Map<String, String> fields = new HashMap<>();
581 fields.put("uuid", "text");
582 fields.put("emp_name", "text");
583 fields.put("emp_salary", "varint");
584 consistencyInfo.put("type", "eventual");
585 jsonTable.setConsistencyInfo(consistencyInfo);
586 jsonTable.setKeyspaceName(keyspaceName);
587 jsonTable.setPartitionKey("emp_name");
588 jsonTable.setClusteringKey("uuid");
589 jsonTable.setTableName(tableName);
590 jsonTable.setFields(fields);
591 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
592 Response response = data.createTable("1", "1", "1",
593 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
594 jsonTable, keyspaceName, "tableName1");
595 System.out.println("#######status is " + response.getStatus());
596 System.out.println("Entity" + response.getEntity());
597 //assertEquals(200, response.getStatus());
598 assertEquals(401, response.getStatus());
601 // Improper parenthesis in key field
603 public void Test3_createTable_badParantesis() throws Exception {
604 String tableNameC ="testTable0";
605 JsonTable jsonTable = new JsonTable();
606 Map<String, String> consistencyInfo = new HashMap<>();
607 Map<String, String> fields = new HashMap<>();
608 fields.put("uuid", "text");
609 fields.put("emp_name", "text");
610 fields.put("emp_salary", "varint");
611 fields.put("PRIMARY KEY", "(emp_name),emp_id)");
612 fields.put("emp_id", "varint");
613 consistencyInfo.put("type", "eventual");
614 jsonTable.setConsistencyInfo(consistencyInfo);
615 jsonTable.setKeyspaceName(keyspaceName);
616 jsonTable.setPrimaryKey("emp_name");
617 jsonTable.setTableName(tableNameC);
618 jsonTable.setClusteringOrder("emp_id Desc");
619 jsonTable.setFields(fields);
620 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
621 Response response = data.createTable("1", "1", "1",
622 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
623 jsonTable, keyspaceName, tableNameC);
624 System.out.println("#######status is " + response.getStatus());
625 System.out.println("Entity" + response.getEntity());
626 //assertEquals(400, response.getStatus());
627 assertTrue(200 != response.getStatus());
631 // good clustering key
633 public void Test3_createTable_1_clusterKey_good() throws Exception {
634 String tableNameC ="testTableC1";
635 JsonTable jsonTable = new JsonTable();
636 Map<String, String> consistencyInfo = new HashMap<>();
637 Map<String, String> fields = new HashMap<>();
638 fields.put("uuid", "text");
639 fields.put("emp_name", "text");
640 fields.put("emp_salary", "varint");
641 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
642 consistencyInfo.put("type", "eventual");
643 jsonTable.setConsistencyInfo(consistencyInfo);
644 jsonTable.setKeyspaceName(keyspaceName);
645 // jsonTable.setPrimaryKey("emp_name");
646 jsonTable.setTableName(tableNameC);
647 jsonTable.setClusteringOrder("emp_salary ASC");
648 jsonTable.setFields(fields);
649 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
650 Response response = data.createTable("1", "1", "1",
651 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
652 jsonTable, keyspaceName, tableNameC);
653 System.out.println("#######status is " + response.getStatus());
654 System.out.println("Entity" + response.getEntity());
655 //assertEquals(200, response.getStatus());
656 assertEquals(401, response.getStatus());
659 // bad partition key=clustering key
661 public void Test3_createTable_2_clusterKey_bad() throws Exception {
662 String tableNameC ="testTableC2";
663 JsonTable jsonTable = new JsonTable();
664 Map<String, String> consistencyInfo = new HashMap<>();
665 Map<String, String> fields = new HashMap<>();
666 fields.put("uuid", "text");
667 fields.put("emp_name", "text");
668 fields.put("emp_salary", "varint");
669 fields.put("PRIMARY KEY", "((emp_name),emp_name)");
670 consistencyInfo.put("type", "eventual");
671 jsonTable.setConsistencyInfo(consistencyInfo);
672 jsonTable.setKeyspaceName(keyspaceName);
673 jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
674 jsonTable.setTableName(tableNameC);
675 jsonTable.setClusteringOrder("emp_salary ASC");
676 jsonTable.setFields(fields);
677 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
678 Response response = data.createTable("1", "1", "1",
679 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
680 jsonTable, keyspaceName, tableNameC);
681 System.out.println("#######status is " + response.getStatus());
682 System.out.println("Entity" + response.getEntity());
683 assertTrue(200 !=response.getStatus());
686 // good composite partition key,clustering key
688 public void Test3_createTable_3_partition_clusterKey_good() throws Exception {
689 String tableNameC ="testTableC3";
690 JsonTable jsonTable = new JsonTable();
691 Map<String, String> consistencyInfo = new HashMap<>();
692 Map<String, String> fields = new HashMap<>();
693 fields.put("uuid", "text");
694 fields.put("emp_name", "text");
695 fields.put("emp_id", "varint");
696 fields.put("emp_salary", "varint");
697 fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
698 consistencyInfo.put("type", "eventual");
699 jsonTable.setConsistencyInfo(consistencyInfo);
700 jsonTable.setKeyspaceName(keyspaceName);
701 jsonTable.setPrimaryKey("emp_name");
702 jsonTable.setTableName(tableNameC);
703 jsonTable.setClusteringOrder("emp_salary ASC");
704 jsonTable.setFields(fields);
705 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
706 Response response = data.createTable("1", "1", "1",
707 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
708 jsonTable, keyspaceName, tableNameC);
709 System.out.println("#######status is " + response.getStatus());
710 System.out.println("Entity" + response.getEntity());
711 //assertEquals(200, response.getStatus());
712 assertEquals(401, response.getStatus());
715 // bad - not all cols in order by of composite partition key,clustering key
717 public void Test3_createTable_4_clusteringOrder_bad() throws Exception {
718 String tableNameC ="testTableC4";
719 JsonTable jsonTable = new JsonTable();
720 Map<String, String> consistencyInfo = new HashMap<>();
721 Map<String, String> fields = new HashMap<>();
722 fields.put("uuid", "text");
723 fields.put("emp_name", "text");
724 fields.put("emp_id", "varint");
725 fields.put("emp_salary", "varint");
726 fields.put("PRIMARY KEY", "((emp_name),emp_id,emp_salary)");
727 consistencyInfo.put("type", "eventual");
728 jsonTable.setConsistencyInfo(consistencyInfo);
729 jsonTable.setKeyspaceName(keyspaceName);
730 jsonTable.setPrimaryKey("emp_name");
731 jsonTable.setTableName(tableNameC);
732 jsonTable.setClusteringOrder("emp_salary ASC");
733 jsonTable.setFields(fields);
734 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
735 Response response = data.createTable("1", "1", "1",
736 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
737 jsonTable, keyspaceName, tableNameC);
738 System.out.println("#######status is " + response.getStatus());
739 System.out.println("Entity" + response.getEntity());
740 assertTrue(200 != response.getStatus());
743 // bad - wrong cols in order by of composite partition key,clustering key
745 public void Test3_createTable_5_clusteringOrder_bad() throws Exception {
746 String tableNameC ="testTableC5";
747 JsonTable jsonTable = new JsonTable();
748 Map<String, String> consistencyInfo = new HashMap<>();
749 Map<String, String> fields = new HashMap<>();
750 fields.put("uuid", "text");
751 fields.put("emp_name", "text");
752 fields.put("emp_id", "varint");
753 fields.put("emp_salary", "varint");
754 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
755 consistencyInfo.put("type", "eventual");
756 jsonTable.setConsistencyInfo(consistencyInfo);
757 jsonTable.setKeyspaceName(keyspaceName);
758 jsonTable.setPrimaryKey("emp_name");
759 jsonTable.setTableName(tableNameC);
760 jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
761 jsonTable.setFields(fields);
762 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
763 Response response = data.createTable("1", "1", "1",
764 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
765 jsonTable, keyspaceName, tableNameC);
766 System.out.println("#######status is " + response.getStatus());
767 System.out.println("Entity" + response.getEntity());
768 assertTrue(200 != response.getStatus());
771 // bad - wrong cols in order by of composite partition key,clustering key
773 public void Test3_createTable_6_clusteringOrder_bad() throws Exception {
774 String tableNameC ="testTableC6";
775 JsonTable jsonTable = new JsonTable();
776 Map<String, String> consistencyInfo = new HashMap<>();
777 Map<String, String> fields = new HashMap<>();
778 fields.put("uuid", "text");
779 fields.put("emp_name", "text");
780 fields.put("emp_id", "varint");
781 fields.put("emp_salary", "varint");
782 fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
783 consistencyInfo.put("type", "eventual");
784 jsonTable.setConsistencyInfo(consistencyInfo);
785 jsonTable.setKeyspaceName(keyspaceName);
786 jsonTable.setPrimaryKey("((uuid,emp_name),emp_id,emp_salary)"); // overridden by
787 jsonTable.setTableName(tableNameC);
788 jsonTable.setClusteringOrder("emp_id desc, emp_salary ASC,uuid desc");
789 jsonTable.setFields(fields);
790 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
791 Response response = data.createTable("1", "1", "1",
792 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
793 jsonTable, keyspaceName, tableNameC);
794 System.out.println("#######status is " + response.getStatus());
795 System.out.println("Entity" + response.getEntity());
796 assertTrue(200 != response.getStatus());
801 public void Test3_createTableIndex_1() throws Exception {
802 String tableNameC ="testTableCinx";
803 JsonTable jsonTable = new JsonTable();
804 Map<String, String> consistencyInfo = new HashMap<>();
805 Map<String, String> fields = new HashMap<>();
806 fields.put("uuid", "text");
807 fields.put("emp_name", "text");
808 fields.put("emp_salary", "varint");
809 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
810 consistencyInfo.put("type", "eventual");
811 jsonTable.setConsistencyInfo(consistencyInfo);
812 jsonTable.setKeyspaceName(keyspaceName);
813 jsonTable.setTableName(tableNameC);
814 jsonTable.setClusteringOrder("emp_salary ASC");
815 jsonTable.setFields(fields);
816 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
817 Response response = data.createTable("1", "1", "1",
818 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
819 jsonTable, keyspaceName, tableNameC);
820 MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
821 Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
822 Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
823 response = data.createIndex("1", "1", "1",
824 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
825 keyspaceName, tableNameC,"uuid",info);
826 //assertEquals(200, response.getStatus());
827 assertEquals(401, response.getStatus());
831 public void Test3_createTableIndex_authorizationWrong() throws Exception {
832 String tableNameC ="testTableCinx";
833 JsonTable jsonTable = new JsonTable();
834 Map<String, String> consistencyInfo = new HashMap<>();
835 Map<String, String> fields = new HashMap<>();
836 fields.put("uuid", "text");
837 fields.put("emp_name", "text");
838 fields.put("emp_salary", "varint");
839 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
840 consistencyInfo.put("type", "eventual");
841 jsonTable.setConsistencyInfo(consistencyInfo);
842 jsonTable.setKeyspaceName(keyspaceName);
843 jsonTable.setTableName(tableNameC);
844 jsonTable.setClusteringOrder("emp_salary ASC");
845 jsonTable.setFields(fields);
846 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
847 Response response = data.createTable("1", "1", "1",
848 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, null,
849 jsonTable, keyspaceName, tableNameC);
850 MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
851 Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
852 Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
853 response = data.createIndex("1", "1", "1",
854 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
855 keyspaceName, tableNameC,"uuid",info);
856 assertEquals(401, response.getStatus());
860 public void Test3_createTableIndex_badindexname() throws Exception {
861 String tableNameC ="testTableCinx";
862 JsonTable jsonTable = new JsonTable();
863 Map<String, String> consistencyInfo = new HashMap<>();
864 Map<String, String> fields = new HashMap<>();
865 fields.put("uuid", "text");
866 fields.put("emp_name", "text");
867 fields.put("emp_salary", "varint");
868 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
869 consistencyInfo.put("type", "eventual");
870 jsonTable.setConsistencyInfo(consistencyInfo);
871 jsonTable.setKeyspaceName(keyspaceName);
872 jsonTable.setTableName(tableNameC);
873 jsonTable.setClusteringOrder("emp_salary ASC");
874 jsonTable.setFields(fields);
875 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
876 Response response = data.createTable("1", "1", "1",
877 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
878 jsonTable, keyspaceName, tableNameC);
879 MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
880 Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
881 Mockito.when(rowParams.getFirst("index_name")).thenReturn("my index");
882 response = data.createIndex("1", "1", "1",
883 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
884 keyspaceName, tableNameC,"uuid",info);
885 //assertEquals(400, response.getStatus());
886 assertEquals(401, response.getStatus());
890 public void Test3_createTableIndex_wrongindex() throws Exception {
891 String tableNameC ="testTableCinx";
892 JsonTable jsonTable = new JsonTable();
893 Map<String, String> consistencyInfo = new HashMap<>();
894 Map<String, String> fields = new HashMap<>();
895 fields.put("uuid", "text");
896 fields.put("emp_name", "text");
897 fields.put("emp_salary", "varint");
898 fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
899 consistencyInfo.put("type", "eventual");
900 jsonTable.setConsistencyInfo(consistencyInfo);
901 jsonTable.setKeyspaceName(keyspaceName);
902 jsonTable.setTableName(tableNameC);
903 jsonTable.setClusteringOrder("emp_salary ASC");
904 jsonTable.setFields(fields);
905 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
906 Response response = data.createTable("1", "1", "1",
907 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
908 jsonTable, keyspaceName, tableNameC);
909 MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
910 Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
911 Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
912 response = data.createIndex("1", "1", "1",
913 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
914 keyspaceName, tableNameC,"id",info);
915 //assertEquals(400, response.getStatus());
916 assertEquals(401, response.getStatus());
920 * @Test public void Test4_insertIntoTable() throws Exception { JsonInsert
921 * jsonInsert = new JsonInsert(); Map<String, String> consistencyInfo = new
922 * HashMap<>(); Map<String, Object> values = new HashMap<>(); values.put("uuid",
923 * "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); values.put("emp_name", "testName");
924 * values.put("emp_salary", 500); consistencyInfo.put("type", "eventual");
925 * jsonInsert.setConsistencyInfo(consistencyInfo);
926 * jsonInsert.setKeyspaceName(keyspaceName); jsonInsert.setTableName(tableName);
927 * jsonInsert.setValues(values);
928 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
929 * MusicUtil.getVersion()); Response response = data.insertIntoTable("1", "1",
930 * "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
931 * jsonInsert, keyspaceName, tableName); assertEquals(200,
932 * response.getStatus()); }
936 public void Test4_insertIntoTable_wrongConsistency() throws Exception {
937 JsonInsert jsonInsert = new JsonInsert();
938 Map<String, String> consistencyInfo = new HashMap<>();
939 Map<String, Object> values = new HashMap<>();
940 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
941 values.put("emp_name", "testName");
942 values.put("emp_salary", 500);
943 consistencyInfo.put("type", "eventual123");
944 jsonInsert.setConsistencyInfo(consistencyInfo);
945 jsonInsert.setKeyspaceName(keyspaceName);
946 jsonInsert.setTableName(tableName);
947 jsonInsert.setValues(values);
948 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
949 Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
950 appName, authorization, jsonInsert, keyspaceName, tableName);
951 assertEquals(400, response.getStatus());
955 public void Test4_insertIntoTable2() throws Exception {
956 JsonInsert jsonInsert = new JsonInsert();
957 Map<String, String> consistencyInfo = new HashMap<>();
958 Map<String, Object> values = new HashMap<>();
959 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
960 values.put("emp_name", "test1");
961 values.put("emp_salary", 1500);
962 consistencyInfo.put("type", "eventual");
963 jsonInsert.setConsistencyInfo(consistencyInfo);
964 jsonInsert.setKeyspaceName(keyspaceName);
965 jsonInsert.setTableName(tableName);
966 jsonInsert.setValues(values);
967 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
968 Response response = data.insertIntoTable("1", "1", "1",
969 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
970 jsonInsert, keyspaceName, tableName);
971 assertEquals(200, response.getStatus());
976 public void Test4_insertIntoTable3() throws Exception {
977 JsonInsert jsonInsert = new JsonInsert();
978 Map<String, String> consistencyInfo = new HashMap<>();
979 Map<String, Object> values = new HashMap<>();
980 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
981 values.put("emp_name", "test1");
982 values.put("emp_salary", 1500);
983 consistencyInfo.put("type", "eventual");
984 jsonInsert.setConsistencyInfo(consistencyInfo);
985 jsonInsert.setKeyspaceName(keyspaceName);
986 jsonInsert.setTableName(tableName);
987 jsonInsert.setValues(values);
988 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
989 Response response = data.insertIntoTable("1", "1", "1",
990 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
991 jsonInsert, keyspaceName, tableName);
992 assertEquals(401, response.getStatus());
997 public void Test4_insertIntoTable4() throws Exception {
998 JsonInsert jsonInsert = new JsonInsert();
999 Map<String, String> consistencyInfo = new HashMap<>();
1000 Map<String, Object> values = new HashMap<>();
1001 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1002 values.put("emp_name", "test1");
1003 values.put("emp_salary", 1500);
1004 consistencyInfo.put("type", "eventual");
1005 jsonInsert.setConsistencyInfo(consistencyInfo);
1006 jsonInsert.setKeyspaceName(keyspaceName);
1007 jsonInsert.setTableName(tableName);
1008 jsonInsert.setValues(values);
1009 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1010 Response response = data.insertIntoTable("1", "1", "1",
1011 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1012 jsonInsert, keyspaceName, "wrong");
1013 assertEquals(400, response.getStatus());
1017 public void Test4_insertIntoTable5() throws Exception {
1018 JsonInsert jsonInsert = new JsonInsert();
1019 Map<String, String> consistencyInfo = new HashMap<>();
1020 Map<String, Object> values = new HashMap<>();
1021 values.put("id", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1022 values.put("emp_name", "test1");
1023 values.put("emp_salary", 1500);
1024 consistencyInfo.put("type", "eventual");
1025 jsonInsert.setConsistencyInfo(consistencyInfo);
1026 jsonInsert.setKeyspaceName(keyspaceName);
1027 jsonInsert.setTableName(tableName);
1028 jsonInsert.setValues(values);
1029 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1030 Response response = data.insertIntoTable("1", "1", "1",
1031 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1032 jsonInsert, keyspaceName, tableName);
1033 assertEquals(400, response.getStatus());
1037 public void Test4_insertIntoTable6() throws Exception {
1038 JsonInsert jsonInsert = new JsonInsert();
1039 Map<String, String> consistencyInfo = new HashMap<>();
1040 Map<String, Object> values = new HashMap<>();
1041 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1042 values.put("emp_salary", 1500);
1043 consistencyInfo.put("type", "eventual");
1044 jsonInsert.setConsistencyInfo(consistencyInfo);
1045 jsonInsert.setKeyspaceName(keyspaceName);
1046 jsonInsert.setTableName(tableName);
1047 jsonInsert.setValues(values);
1048 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1049 Response response = data.insertIntoTable("1", "1", "1",
1050 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1051 jsonInsert, keyspaceName, tableName);
1052 assertEquals(400, response.getStatus());
1056 public void Test4_insertIntoTable7() throws Exception {
1057 JsonInsert jsonInsert = new JsonInsert();
1058 Map<String, String> consistencyInfo = new HashMap<>();
1059 Map<String, Object> values = new HashMap<>();
1060 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1061 values.put("emp_name", "test2");
1062 values.put("emp_salary", 1500);
1063 consistencyInfo.put("type", "eventual");
1064 jsonInsert.setConsistencyInfo(consistencyInfo);
1065 jsonInsert.setKeyspaceName(keyspaceName);
1066 jsonInsert.setTableName(tableName);
1067 jsonInsert.setValues(values);
1068 jsonInsert.setTtl("1000");
1069 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1070 Response response = data.insertIntoTable("1", "1", "1",
1071 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1072 jsonInsert, keyspaceName, tableName);
1073 assertEquals(200, response.getStatus());
1077 public void Test4_insertIntoTable8() throws Exception {
1078 JsonInsert jsonInsert = new JsonInsert();
1079 Map<String, String> consistencyInfo = new HashMap<>();
1080 Map<String, Object> values = new HashMap<>();
1081 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1082 values.put("emp_name", "test3");
1083 values.put("emp_salary", 1500);
1084 consistencyInfo.put("type", "eventual");
1085 jsonInsert.setConsistencyInfo(consistencyInfo);
1086 jsonInsert.setKeyspaceName(keyspaceName);
1087 jsonInsert.setTableName(tableName);
1088 jsonInsert.setValues(values);
1089 jsonInsert.setTimestamp("15000");
1090 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1091 Response response = data.insertIntoTable("1", "1", "1",
1092 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1093 jsonInsert, keyspaceName, tableName);
1094 assertEquals(200, response.getStatus());
1098 public void Test4_insertIntoTable9() throws Exception {
1099 JsonInsert jsonInsert = new JsonInsert();
1100 Map<String, String> consistencyInfo = new HashMap<>();
1101 Map<String, Object> values = new HashMap<>();
1102 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1103 values.put("emp_name", "test4");
1104 values.put("emp_salary", 1500);
1105 consistencyInfo.put("type", "eventual");
1106 jsonInsert.setConsistencyInfo(consistencyInfo);
1107 jsonInsert.setKeyspaceName(keyspaceName);
1108 jsonInsert.setTableName(tableName);
1109 jsonInsert.setValues(values);
1110 jsonInsert.setTtl("1000");
1111 jsonInsert.setTimestamp("15000");
1112 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1113 Response response = data.insertIntoTable("1", "1", "1",
1114 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1115 jsonInsert, keyspaceName, tableName);
1116 assertEquals(200, response.getStatus());
1120 * @Test public void Test4_insertIntoTable10() throws Exception { JsonInsert
1121 * jsonInsert = new JsonInsert(); Map<String, String> consistencyInfo = new
1122 * HashMap<>(); Map<String, Object> values = new HashMap<>(); values.put("uuid",
1123 * "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); values.put("emp_name", "test5");
1124 * values.put("emp_salary", 1500); consistencyInfo.put("type", "critical");
1125 * jsonInsert.setConsistencyInfo(consistencyInfo);
1126 * jsonInsert.setKeyspaceName(keyspaceName); jsonInsert.setTableName(tableName);
1127 * jsonInsert.setValues(values); jsonInsert.setTtl("1000");
1128 * jsonInsert.setTimestamp("15000");
1129 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
1130 * MusicUtil.getVersion()); Response response = data.insertIntoTable("1", "1",
1131 * "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1132 * jsonInsert, keyspaceName, tableName); assertEquals(400,
1133 * response.getStatus()); }
1137 * @Test public void Test4_insertIntoTable11() throws Exception { JsonInsert
1138 * jsonInsert = new JsonInsert(); Map<String, String> consistencyInfo = new
1139 * HashMap<>(); Map<String, Object> values = new HashMap<>(); values.put("uuid",
1140 * "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); values.put("emp_name", "test6");
1141 * values.put("emp_salary", 1500); consistencyInfo.put("type",
1142 * "atomic_delete_lock"); jsonInsert.setConsistencyInfo(consistencyInfo);
1143 * jsonInsert.setKeyspaceName(keyspaceName); jsonInsert.setTableName(tableName);
1144 * jsonInsert.setValues(values); jsonInsert.setTtl("1000");
1145 * jsonInsert.setTimestamp("15000");
1146 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
1147 * MusicUtil.getVersion()); Response response = data.insertIntoTable("1", "1",
1148 * "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1149 * jsonInsert, keyspaceName, tableName); //TODO 200 assertEquals(400,
1150 * response.getStatus()); }
1154 public void Test4_insertIntoTable12() throws Exception {
1155 JsonInsert jsonInsert = new JsonInsert();
1156 Map<String, String> consistencyInfo = new HashMap<>();
1157 Map<String, Object> values = new HashMap<>();
1158 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
1159 values.put("emp_name", "test7");
1160 values.put("emp_salary", 1500);
1161 consistencyInfo.put("type", "atomic");
1162 jsonInsert.setConsistencyInfo(consistencyInfo);
1163 jsonInsert.setKeyspaceName(keyspaceName);
1164 jsonInsert.setTableName(tableName);
1165 jsonInsert.setValues(values);
1166 jsonInsert.setTtl("1000");
1167 jsonInsert.setTimestamp("15000");
1168 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1169 Response response = data.insertIntoTable("1", "1", "1",
1170 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1171 jsonInsert, keyspaceName, tableName);
1172 assertEquals(200, response.getStatus());
1176 public void Test5_updateTable() throws Exception {
1177 JsonUpdate jsonUpdate = new JsonUpdate();
1178 Map<String, String> consistencyInfo = new HashMap<>();
1179 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1180 Map<String, Object> values = new HashMap<>();
1181 row.add("emp_name", "testName");
1182 values.put("emp_salary", 2500);
1183 consistencyInfo.put("type", "atomic");
1184 jsonUpdate.setConsistencyInfo(consistencyInfo);
1185 jsonUpdate.setKeyspaceName(keyspaceName);
1186 jsonUpdate.setTableName(tableName);
1187 jsonUpdate.setValues(values);
1188 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1189 Mockito.when(info.getQueryParameters()).thenReturn(row);
1190 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1191 authorization, jsonUpdate, keyspaceName, tableName, info);
1192 //assertEquals(200, response.getStatus());
1193 assertEquals(401, response.getStatus());
1197 public void Test5_updateTable_wrongTablename() throws Exception {
1198 JsonUpdate jsonUpdate = new JsonUpdate();
1199 Map<String, String> consistencyInfo = new HashMap<>();
1200 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1201 Map<String, Object> values = new HashMap<>();
1202 row.add("emp_name", "testName");
1203 values.put("emp_salary", 2500);
1204 consistencyInfo.put("type", "atomic");
1205 jsonUpdate.setConsistencyInfo(consistencyInfo);
1206 jsonUpdate.setKeyspaceName(keyspaceName);
1207 jsonUpdate.setTableName("tableName123");
1208 jsonUpdate.setValues(values);
1209 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1210 Mockito.when(info.getQueryParameters()).thenReturn(row);
1211 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1212 authorization, jsonUpdate, keyspaceName, "tableName123", info);
1213 assertEquals(401, response.getStatus());
1217 public void Test5_updateTable_wrongConsistency() throws Exception {
1218 JsonUpdate jsonUpdate = new JsonUpdate();
1219 Map<String, String> consistencyInfo = new HashMap<>();
1220 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1221 Map<String, Object> values = new HashMap<>();
1222 row.add("emp_name", "testName");
1223 values.put("emp_salary", 2500);
1224 consistencyInfo.put("type", "eventual123");
1225 jsonUpdate.setConsistencyInfo(consistencyInfo);
1226 jsonUpdate.setKeyspaceName(keyspaceName);
1227 jsonUpdate.setTableName(tableName);
1228 jsonUpdate.setValues(values);
1229 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1230 Mockito.when(info.getQueryParameters()).thenReturn(row);
1231 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1232 authorization, jsonUpdate, keyspaceName, tableName, info);
1233 assertEquals(401, response.getStatus());
1236 // need mock code to create error for MusicCore methods
1238 public void Test5_updateTableAuthE() throws Exception {
1239 MockitoAnnotations.initMocks(this);
1240 JsonUpdate jsonUpdate = new JsonUpdate();
1241 Map<String, String> consistencyInfo = new HashMap<>();
1242 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1243 Map<String, Object> values = new HashMap<>();
1244 row.add("emp_name", "testName");
1245 values.put("emp_salary", 2500);
1246 consistencyInfo.put("type", "atomic");
1247 jsonUpdate.setConsistencyInfo(consistencyInfo);
1248 jsonUpdate.setKeyspaceName(keyspaceName);
1249 jsonUpdate.setTableName(tableName);
1250 jsonUpdate.setValues(values);
1251 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1252 Mockito.when(info.getQueryParameters()).thenReturn(row);
1253 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1254 authorization, jsonUpdate, keyspaceName, tableName, info);
1255 //assertEquals(200, response.getStatus());
1256 assertEquals(401, response.getStatus());
1260 public void Test5_updateTableAuthException1() throws Exception {
1261 JsonUpdate jsonUpdate = new JsonUpdate();
1262 Map<String, String> consistencyInfo = new HashMap<>();
1263 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1264 Map<String, Object> values = new HashMap<>();
1265 row.add("emp_name", "testName");
1266 values.put("emp_salary", 2500);
1267 consistencyInfo.put("type", "atomic");
1268 jsonUpdate.setConsistencyInfo(consistencyInfo);
1269 jsonUpdate.setKeyspaceName(keyspaceName);
1270 jsonUpdate.setTableName(tableName);
1271 jsonUpdate.setValues(values);
1272 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1273 Mockito.when(info.getQueryParameters()).thenReturn(row);
1274 String authDatax = ":";//+password;
1275 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
1277 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1278 authorizationx, jsonUpdate, keyspaceName, tableName, info);
1279 assertEquals(200, response.getStatus());
1280 } catch(RuntimeException e) {
1281 System.out.println("Update table Runtime exception="+e);
1286 public void Test5_updateTableAuthEmpty() throws Exception {
1287 JsonUpdate jsonUpdate = new JsonUpdate();
1288 Map<String, String> consistencyInfo = new HashMap<>();
1289 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1290 Map<String, Object> values = new HashMap<>();
1291 row.add("emp_name", "testName");
1292 values.put("emp_salary", 2500);
1293 consistencyInfo.put("type", "atomic");
1294 jsonUpdate.setConsistencyInfo(consistencyInfo);
1295 jsonUpdate.setKeyspaceName(keyspaceName);
1296 jsonUpdate.setTableName(tableName);
1297 jsonUpdate.setValues(values);
1298 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1299 Mockito.when(info.getQueryParameters()).thenReturn(row);
1300 String authDatax =":"+password;
1301 String authorizationx = new String(Base64.encode(authDatax.getBytes()));
1302 String appNamex="xx";
1304 // Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1305 Response response = data.updateTable("1", "1", "1", "", appNamex,
1306 authorizationx, jsonUpdate, keyspaceName, tableName, info);
1307 assertEquals(200, response.getStatus());
1308 } catch(RuntimeException e) {
1309 System.out.println("Update table Runtime exception="+e);
1314 public void Test5_updateTable_wrongauth() throws Exception {
1315 JsonUpdate jsonUpdate = new JsonUpdate();
1316 Map<String, String> consistencyInfo = new HashMap<>();
1317 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1318 Map<String, Object> values = new HashMap<>();
1319 row.add("emp_name", "testName");
1320 values.put("emp_salary", 2500);
1321 consistencyInfo.put("type", "atomic");
1322 jsonUpdate.setConsistencyInfo(consistencyInfo);
1323 jsonUpdate.setKeyspaceName(keyspaceName);
1324 jsonUpdate.setTableName(tableName);
1325 jsonUpdate.setValues(values);
1326 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1327 Mockito.when(info.getQueryParameters()).thenReturn(row);
1328 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1329 wrongAuthorization, jsonUpdate, keyspaceName, tableName, info);
1330 assertEquals(401, response.getStatus());
1334 public void Test5_updateTable_invalidColumn() throws Exception {
1335 JsonUpdate jsonUpdate = new JsonUpdate();
1336 Map<String, String> consistencyInfo = new HashMap<>();
1337 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1338 Map<String, Object> values = new HashMap<>();
1339 row.add("id", "testName");
1340 values.put("emp_salary", 2500);
1341 consistencyInfo.put("type", "atomic");
1342 jsonUpdate.setConsistencyInfo(consistencyInfo);
1343 jsonUpdate.setKeyspaceName(keyspaceName);
1344 jsonUpdate.setTableName(tableName);
1345 jsonUpdate.setValues(values);
1346 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1347 Mockito.when(info.getQueryParameters()).thenReturn(row);
1348 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1349 authorization, jsonUpdate, keyspaceName, tableName, info);
1350 assertEquals(401, response.getStatus());
1354 public void Test5_updateTable_ttl() throws Exception {
1355 JsonUpdate jsonUpdate = new JsonUpdate();
1356 Map<String, String> consistencyInfo = new HashMap<>();
1357 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1358 Map<String, Object> values = new HashMap<>();
1359 row.add("emp_name", "testName8");
1360 values.put("emp_salary", 2500);
1361 consistencyInfo.put("type", "atomic");
1362 jsonUpdate.setConsistencyInfo(consistencyInfo);
1363 jsonUpdate.setKeyspaceName(keyspaceName);
1364 jsonUpdate.setTableName(tableName);
1365 jsonUpdate.setValues(values);
1366 jsonUpdate.setTtl("1000");
1367 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1368 Mockito.when(info.getQueryParameters()).thenReturn(row);
1369 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1370 authorization, jsonUpdate, keyspaceName, tableName, info);
1371 assertEquals(401, response.getStatus());
1375 public void Test5_updateTable_timsetamp() throws Exception {
1376 JsonUpdate jsonUpdate = new JsonUpdate();
1377 Map<String, String> consistencyInfo = new HashMap<>();
1378 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1379 Map<String, Object> values = new HashMap<>();
1380 row.add("emp_name", "testName9");
1381 values.put("emp_salary", 2500);
1382 consistencyInfo.put("type", "atomic");
1383 jsonUpdate.setConsistencyInfo(consistencyInfo);
1384 jsonUpdate.setKeyspaceName(keyspaceName);
1385 jsonUpdate.setTableName(tableName);
1386 jsonUpdate.setValues(values);
1387 jsonUpdate.setTimestamp("15000");
1388 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1389 Mockito.when(info.getQueryParameters()).thenReturn(row);
1390 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1391 authorization, jsonUpdate, keyspaceName, tableName, info);
1392 assertEquals(401, response.getStatus());
1396 public void Test5_updateTable_ttl_timestamp() throws Exception {
1397 JsonUpdate jsonUpdate = new JsonUpdate();
1398 Map<String, String> consistencyInfo = new HashMap<>();
1399 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1400 Map<String, Object> values = new HashMap<>();
1401 row.add("emp_name", "testName10");
1402 values.put("emp_salary", 2500);
1403 consistencyInfo.put("type", "atomic");
1404 jsonUpdate.setConsistencyInfo(consistencyInfo);
1405 jsonUpdate.setKeyspaceName(keyspaceName);
1406 jsonUpdate.setTableName(tableName);
1407 jsonUpdate.setValues(values);
1408 jsonUpdate.setTtl("1000");
1409 jsonUpdate.setTimestamp("15000");
1410 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1411 Mockito.when(info.getQueryParameters()).thenReturn(row);
1412 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1413 authorization, jsonUpdate, keyspaceName, tableName, info);
1414 assertEquals(401, response.getStatus());
1418 public void Test5_updateTable_rowIdEmpty() throws Exception {
1419 JsonUpdate jsonUpdate = new JsonUpdate();
1420 Map<String, String> consistencyInfo = new HashMap<>();
1421 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1422 Map<String, Object> values = new HashMap<>();
1423 //row.add("emp_name", "testName3");
1424 values.put("emp_salary", 2500);
1425 consistencyInfo.put("type", "atomic");
1426 jsonUpdate.setConsistencyInfo(consistencyInfo);
1427 jsonUpdate.setKeyspaceName(keyspaceName);
1428 jsonUpdate.setTableName(tableName);
1429 jsonUpdate.setValues(values);
1430 jsonUpdate.setTtl("1000");
1431 jsonUpdate.setTimestamp("15000");
1432 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1433 Mockito.when(info.getQueryParameters()).thenReturn(row);
1434 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1435 authorization, jsonUpdate, keyspaceName, tableName, info);
1436 assertEquals(401, response.getStatus());
1440 public void Test5_updateTable_conditions() throws Exception {
1441 JsonUpdate jsonUpdate = new JsonUpdate();
1442 Map<String, String> consistencyInfo = new HashMap<>();
1443 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1444 Map<String, Object> values = new HashMap<>();
1445 Map<String, Object> conditions = new HashMap<>();
1446 conditions.put("emp_name","testName3");
1447 row.add("emp_name", "testName3");
1448 values.put("emp_salary", 2500);
1449 consistencyInfo.put("type", "atomic");
1450 jsonUpdate.setConsistencyInfo(consistencyInfo);
1451 jsonUpdate.setKeyspaceName(keyspaceName);
1452 jsonUpdate.setTableName(tableName);
1453 jsonUpdate.setValues(values);
1454 jsonUpdate.setConditions(conditions);
1455 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1456 Mockito.when(info.getQueryParameters()).thenReturn(row);
1457 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1458 authorization, jsonUpdate, keyspaceName, tableName, info);
1459 assertEquals(401, response.getStatus());
1463 public void Test5_updateTable_eventual() throws Exception {
1464 JsonUpdate jsonUpdate = new JsonUpdate();
1465 Map<String, String> consistencyInfo = new HashMap<>();
1466 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1467 Map<String, Object> values = new HashMap<>();
1468 row.add("emp_name", "testName");
1469 values.put("emp_salary", 2500);
1470 consistencyInfo.put("type", "eventual");
1471 jsonUpdate.setConsistencyInfo(consistencyInfo);
1472 jsonUpdate.setKeyspaceName(keyspaceName);
1473 jsonUpdate.setTableName(tableName);
1474 jsonUpdate.setValues(values);
1475 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1476 Mockito.when(info.getQueryParameters()).thenReturn(row);
1477 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1478 authorization, jsonUpdate, keyspaceName, tableName, info);
1479 assertEquals(401, response.getStatus());
1483 public void Test5_updateTable_critical() throws Exception {
1484 JsonUpdate jsonUpdate = new JsonUpdate();
1485 Map<String, String> consistencyInfo = new HashMap<>();
1486 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1487 Map<String, Object> values = new HashMap<>();
1488 row.add("emp_name", "testName");
1489 values.put("emp_salary", 2500);
1490 consistencyInfo.put("type", "critical");
1491 jsonUpdate.setConsistencyInfo(consistencyInfo);
1492 jsonUpdate.setKeyspaceName(keyspaceName);
1493 jsonUpdate.setTableName(tableName);
1494 jsonUpdate.setValues(values);
1495 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1496 Mockito.when(info.getQueryParameters()).thenReturn(row);
1497 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1498 authorization, jsonUpdate, keyspaceName, tableName, info);
1499 assertEquals(401, response.getStatus());
1503 public void Test5_updateTable_atomic_delete_lock() throws Exception {
1504 JsonUpdate jsonUpdate = new JsonUpdate();
1505 Map<String, String> consistencyInfo = new HashMap<>();
1506 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1507 Map<String, Object> values = new HashMap<>();
1508 row.add("emp_name", "testName");
1509 values.put("emp_salary", 2500);
1510 consistencyInfo.put("type", "atomic_delete_lock");
1511 jsonUpdate.setConsistencyInfo(consistencyInfo);
1512 jsonUpdate.setKeyspaceName(keyspaceName);
1513 jsonUpdate.setTableName(tableName);
1514 jsonUpdate.setValues(values);
1515 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1516 Mockito.when(info.getQueryParameters()).thenReturn(row);
1517 Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
1518 authorization, jsonUpdate, keyspaceName, tableName, info);
1519 assertEquals(401, response.getStatus());
1523 public void Test6_select() throws Exception {
1524 JsonSelect jsonSelect = new JsonSelect();
1525 Map<String, String> consistencyInfo = new HashMap<>();
1526 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1527 row.add("emp_name", "testName");
1528 consistencyInfo.put("type", "atomic");
1529 jsonSelect.setConsistencyInfo(consistencyInfo);
1530 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1531 Mockito.when(info.getQueryParameters()).thenReturn(row);
1532 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1533 appName, authorization, keyspaceName, tableName, info);
1534 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
1535 HashMap<String, Object> result = map.get("result");
1536 //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
1540 public void Test6_select_withException() throws Exception {
1541 JsonSelect jsonSelect = new JsonSelect();
1542 Map<String, String> consistencyInfo = new HashMap<>();
1543 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1544 row.add("emp_name", "testName");
1545 consistencyInfo.put("type", "atomic");
1546 jsonSelect.setConsistencyInfo(consistencyInfo);
1547 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1548 Mockito.when(info.getQueryParameters()).thenReturn(row);
1549 RestMusicDataAPI spyData = Mockito.spy(RestMusicDataAPI.class);
1550 Mockito.doThrow(MusicServiceException.class).when(spyData).selectSpecificQuery("v2", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password, keyspaceName, tableName, info, -1);
1551 Response response = spyData.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1552 appName, authorization, keyspaceName, tableName, info);
1553 assertEquals(401, response.getStatus());
1557 public void Test6_select_nodata() throws Exception {
1558 JsonSelect jsonSelect = new JsonSelect();
1559 Map<String, String> consistencyInfo = new HashMap<>();
1560 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1561 row.add("emp_name", "testName12");
1562 consistencyInfo.put("type", "atomic");
1563 jsonSelect.setConsistencyInfo(consistencyInfo);
1564 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1565 Mockito.when(info.getQueryParameters()).thenReturn(row);
1566 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1567 appName, authorization, keyspaceName, tableName, info);
1568 assertEquals(401, response.getStatus());
1572 public void Test6_selectCritical() throws Exception {
1573 JsonInsert jsonInsert = new JsonInsert();
1574 Map<String, String> consistencyInfo = new HashMap<>();
1575 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1576 row.add("emp_name", "testName");
1577 consistencyInfo.put("type", "atomic");
1578 jsonInsert.setConsistencyInfo(consistencyInfo);
1579 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1580 Mockito.when(info.getQueryParameters()).thenReturn(row);
1581 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1582 appName, authorization, jsonInsert, keyspaceName, tableName,info);
1583 HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
1584 HashMap<String, Object> result = map.get("result");
1585 //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
1589 public void Test6_selectCritical_wrongAuthorization() throws Exception {
1590 JsonInsert jsonInsert = new JsonInsert();
1591 Map<String, String> consistencyInfo = new HashMap<>();
1592 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1593 row.add("emp_name", "testName");
1594 consistencyInfo.put("type", "atomic");
1595 jsonInsert.setConsistencyInfo(consistencyInfo);
1596 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1597 Mockito.when(info.getQueryParameters()).thenReturn(row);
1598 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1599 appName, wrongAuthorization, jsonInsert, keyspaceName, tableName,info);
1600 /*HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
1601 HashMap<String, Object> result = map.get("result");
1602 assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());*/
1603 assertEquals(401, response.getStatus());
1607 public void Test6_selectCritical_without_lockID() throws Exception {
1608 JsonInsert jsonInsert = new JsonInsert();
1609 Map<String, String> consistencyInfo = new HashMap<>();
1610 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1611 row.add("emp_name", "testName");
1612 consistencyInfo.put("type", "critical");
1613 jsonInsert.setConsistencyInfo(consistencyInfo);
1614 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1615 Mockito.when(info.getQueryParameters()).thenReturn(row);
1616 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1617 appName, authorization, jsonInsert, keyspaceName, tableName,info);
1618 assertEquals(401, response.getStatus());
1622 public void Test6_selectCritical_with_atomic_delete_lock() throws Exception {
1623 JsonInsert jsonInsert = new JsonInsert();
1624 Map<String, String> consistencyInfo = new HashMap<>();
1625 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1626 row.add("emp_name", "testName");
1627 consistencyInfo.put("type", "atomic_delete_lock");
1628 jsonInsert.setConsistencyInfo(consistencyInfo);
1629 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1630 Mockito.when(info.getQueryParameters()).thenReturn(row);
1631 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1632 appName, authorization, jsonInsert, keyspaceName, tableName,info);
1633 assertEquals(401, response.getStatus());
1637 public void Test6_selectCritical_with_nodata() throws Exception {
1638 JsonInsert jsonInsert = new JsonInsert();
1639 Map<String, String> consistencyInfo = new HashMap<>();
1640 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1641 row.add("emp_name", "testName12");
1642 consistencyInfo.put("type", "atomic_delete_lock");
1643 jsonInsert.setConsistencyInfo(consistencyInfo);
1644 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1645 Mockito.when(info.getQueryParameters()).thenReturn(row);
1646 Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1647 appName, authorization, jsonInsert, keyspaceName, tableName,info);
1648 assertEquals(401, response.getStatus());
1652 public void Test6_select_all() throws Exception {
1653 JsonSelect jsonSelect = new JsonSelect();
1654 Map<String, String> consistencyInfo = new HashMap<>();
1655 MultivaluedMap<String, String> row = new MultivaluedMapImpl();;
1656 consistencyInfo.put("type", "atomic");
1657 jsonSelect.setConsistencyInfo(consistencyInfo);
1658 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1659 Mockito.when(info.getQueryParameters()).thenReturn(row);
1660 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1661 appName, authorization, keyspaceName, tableName, info);
1662 assertEquals(401, response.getStatus());
1666 public void Test6_select_all_wrongAuthorization() throws Exception {
1667 JsonSelect jsonSelect = new JsonSelect();
1668 Map<String, String> consistencyInfo = new HashMap<>();
1669 MultivaluedMap<String, String> row = new MultivaluedMapImpl();;
1670 consistencyInfo.put("type", "atomic");
1671 jsonSelect.setConsistencyInfo(consistencyInfo);
1672 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1673 Mockito.when(info.getQueryParameters()).thenReturn(row);
1674 Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1675 appName, wrongAuthorization, keyspaceName, tableName, info);
1676 assertEquals(401, response.getStatus());
1680 public void Test6_deleteFromTable() throws Exception {
1681 JsonDelete jsonDelete = new JsonDelete();
1682 Map<String, String> consistencyInfo = new HashMap<>();
1683 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1684 row.add("emp_name", "test1");
1685 consistencyInfo.put("type", "atomic");
1686 jsonDelete.setConsistencyInfo(consistencyInfo);
1687 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1688 Mockito.when(info.getQueryParameters()).thenReturn(row);
1689 Response response = data.deleteFromTable("1", "1", "1",
1690 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1691 jsonDelete, keyspaceName, tableName, info);
1692 assertEquals(401, response.getStatus());
1696 public void Test6_deleteFromTable_wrongAuthorization() throws Exception {
1697 JsonDelete jsonDelete = new JsonDelete();
1698 Map<String, String> consistencyInfo = new HashMap<>();
1699 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1700 row.add("emp_name", "test1");
1701 consistencyInfo.put("type", "atomic");
1702 jsonDelete.setConsistencyInfo(consistencyInfo);
1703 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1704 Mockito.when(info.getQueryParameters()).thenReturn(row);
1705 Response response = data.deleteFromTable("1", "1", "1",
1706 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
1707 jsonDelete, keyspaceName, tableName, info);
1708 assertEquals(401, response.getStatus());
1713 * @Test public void Test6_deleteFromTable1() throws Exception { JsonDelete
1714 * jsonDelete = new JsonDelete(); Map<String, String> consistencyInfo = new
1715 * HashMap<>(); MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1716 * consistencyInfo.put("type", "atomic");
1717 * jsonDelete.setConsistencyInfo(consistencyInfo);
1718 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
1719 * MusicUtil.getVersion());
1720 * Mockito.when(info.getQueryParameters()).thenReturn(row); Response response =
1721 * data.deleteFromTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1722 * appName, authorization, jsonDelete, keyspaceName, tableName, info);
1723 * assertEquals(400, response.getStatus()); }
1728 public void Test6_deleteFromTable2() throws Exception {
1729 JsonDelete jsonDelete = new JsonDelete();
1730 Map<String, String> consistencyInfo = new HashMap<>();
1731 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1732 row.add("emp_name", "test1");
1733 consistencyInfo.put("type", "atomic");
1734 jsonDelete.setConsistencyInfo(consistencyInfo);
1735 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1736 Mockito.when(info.getQueryParameters()).thenReturn(row);
1737 Response response = data.deleteFromTable("1", "1", "1",
1738 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1739 null, keyspaceName, tableName, info);
1740 assertEquals(401, response.getStatus());
1744 public void Test6_deleteFromTable_columns() throws Exception {
1745 JsonDelete jsonDelete = new JsonDelete();
1746 Map<String, String> consistencyInfo = new HashMap<>();
1747 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1748 row.add("emp_name", "test1");
1749 consistencyInfo.put("type", "atomic");
1750 jsonDelete.setConsistencyInfo(consistencyInfo);
1751 ArrayList<String> columns = new ArrayList<>();
1752 columns.add("uuid");
1753 jsonDelete.setColumns(columns);
1754 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1755 Mockito.when(info.getQueryParameters()).thenReturn(row);
1756 Response response = data.deleteFromTable("1", "1", "1",
1757 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1758 jsonDelete, keyspaceName, tableName, info);
1759 assertEquals(401, response.getStatus());
1763 public void Test6_deleteFromTable_conditions() throws Exception {
1764 JsonDelete jsonDelete = new JsonDelete();
1765 Map<String, String> consistencyInfo = new HashMap<>();
1766 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1767 Map<String, Object> conditions = new HashMap<>();
1768 conditions.put("emp_name","testName3");
1769 row.add("emp_name", "test1");
1770 consistencyInfo.put("type", "atomic");
1771 jsonDelete.setConsistencyInfo(consistencyInfo);
1772 ArrayList<String> columns = new ArrayList<>();
1773 jsonDelete.setConditions(conditions);
1774 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1775 Mockito.when(info.getQueryParameters()).thenReturn(row);
1776 Response response = data.deleteFromTable("1", "1", "1",
1777 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1778 jsonDelete, keyspaceName, tableName, info);
1779 assertEquals(401, response.getStatus());
1783 public void Test6_deleteFromTable_eventual() throws Exception {
1784 JsonDelete jsonDelete = new JsonDelete();
1785 Map<String, String> consistencyInfo = new HashMap<>();
1786 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1787 row.add("emp_name", "test2");
1788 consistencyInfo.put("type", "eventual");
1789 jsonDelete.setConsistencyInfo(consistencyInfo);
1790 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1791 Mockito.when(info.getQueryParameters()).thenReturn(row);
1792 Response response = data.deleteFromTable("1", "1", "1",
1793 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1794 jsonDelete, keyspaceName, tableName, info);
1795 assertEquals(401, response.getStatus());
1799 public void Test6_deleteFromTable_wrongConsistency() throws Exception {
1800 JsonDelete jsonDelete = new JsonDelete();
1801 Map<String, String> consistencyInfo = new HashMap<>();
1802 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1803 row.add("emp_name", "test2");
1804 consistencyInfo.put("type", "eventual123");
1805 jsonDelete.setConsistencyInfo(consistencyInfo);
1806 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1807 Mockito.when(info.getQueryParameters()).thenReturn(row);
1808 Response response = data.deleteFromTable("1", "1", "1",
1809 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1810 jsonDelete, keyspaceName, tableName, info);
1811 assertEquals(401, response.getStatus());
1815 public void Test6_deleteFromTable_critical() throws Exception {
1816 JsonDelete jsonDelete = new JsonDelete();
1817 Map<String, String> consistencyInfo = new HashMap<>();
1818 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1819 row.add("emp_name", "test2");
1820 consistencyInfo.put("type", "critical");
1821 jsonDelete.setConsistencyInfo(consistencyInfo);
1822 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1823 Mockito.when(info.getQueryParameters()).thenReturn(row);
1824 Response response = data.deleteFromTable("1", "1", "1",
1825 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1826 jsonDelete, keyspaceName, tableName, info);
1827 assertEquals(401, response.getStatus());
1831 public void Test6_deleteFromTable_atomic_delete_lock() throws Exception {
1832 JsonDelete jsonDelete = new JsonDelete();
1833 Map<String, String> consistencyInfo = new HashMap<>();
1834 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
1835 row.add("emp_name", "test3");
1836 consistencyInfo.put("type", "atomic_delete_lock");
1837 jsonDelete.setConsistencyInfo(consistencyInfo);
1838 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1839 Mockito.when(info.getQueryParameters()).thenReturn(row);
1840 Response response = data.deleteFromTable("1", "1", "1",
1841 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1842 jsonDelete, keyspaceName, tableName, info);
1843 assertEquals(401, response.getStatus());
1847 public void Test7_dropTable() throws Exception {
1848 JsonTable jsonTable = new JsonTable();
1849 Map<String, String> consistencyInfo = new HashMap<>();
1850 consistencyInfo.put("type", "atomic");
1851 jsonTable.setConsistencyInfo(consistencyInfo);
1852 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1853 Response response = data.dropTable("1", "1", "1",
1854 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
1855 keyspaceName, tableName);
1856 assertEquals(401, response.getStatus());
1860 public void Test7_dropTable_wrongAuthorization() throws Exception {
1861 JsonTable jsonTable = new JsonTable();
1862 Map<String, String> consistencyInfo = new HashMap<>();
1863 consistencyInfo.put("type", "atomic");
1864 jsonTable.setConsistencyInfo(consistencyInfo);
1865 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1866 Response response = data.dropTable("1", "1", "1",
1867 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
1868 keyspaceName, tableName);
1869 assertEquals(401, response.getStatus());
1874 * @Test public void Test8_deleteKeyspace() throws Exception { JsonKeySpace
1875 * jsonKeyspace = new JsonKeySpace(); Map<String, String> consistencyInfo = new
1876 * HashMap<>(); Map<String, Object> replicationInfo = new HashMap<>();
1877 * consistencyInfo.put("type", "eventual"); replicationInfo.put("class",
1878 * "SimpleStrategy"); replicationInfo.put("replication_factor", 1);
1879 * jsonKeyspace.setConsistencyInfo(consistencyInfo);
1880 * jsonKeyspace.setDurabilityOfWrites("true");
1881 * jsonKeyspace.setKeyspaceName("TestApp1");
1882 * jsonKeyspace.setReplicationInfo(replicationInfo);
1883 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
1884 * MusicUtil.getVersion()); Response response = data.dropKeySpace("1", "1", "1",
1885 * "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", authorization,appName, keyspaceName);
1886 * assertEquals(200, response.getStatus()); }
1890 public void Test8_deleteKeyspace1() throws Exception {
1891 JsonKeySpace jsonKeyspace = new JsonKeySpace();
1892 Map<String, String> consistencyInfo = new HashMap<>();
1893 Map<String, Object> replicationInfo = new HashMap<>();
1894 consistencyInfo.put("type", "eventual");
1895 replicationInfo.put("class", "SimpleStrategy");
1896 replicationInfo.put("replication_factor", 1);
1897 jsonKeyspace.setConsistencyInfo(consistencyInfo);
1898 jsonKeyspace.setDurabilityOfWrites("true");
1899 jsonKeyspace.setKeyspaceName("TestApp1");
1900 jsonKeyspace.setReplicationInfo(replicationInfo);
1901 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1902 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1903 authorization,appName, "keyspaceName");
1904 assertEquals(400, response.getStatus());
1908 public void Test8_deleteKeyspace2() throws Exception {
1909 JsonKeySpace jsonKeyspace = new JsonKeySpace();
1910 Map<String, String> consistencyInfo = new HashMap<>();
1911 Map<String, Object> replicationInfo = new HashMap<>();
1912 consistencyInfo.put("type", "eventual");
1913 replicationInfo.put("class", "SimpleStrategy");
1914 replicationInfo.put("replication_factor", 1);
1915 jsonKeyspace.setConsistencyInfo(consistencyInfo);
1916 jsonKeyspace.setDurabilityOfWrites("true");
1917 jsonKeyspace.setKeyspaceName("TestApp1");
1918 jsonKeyspace.setReplicationInfo(replicationInfo);
1919 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
1920 Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
1921 wrongAuthorization, appName, keyspaceName);
1922 assertEquals(400, response.getStatus());
1926 * @Test public void Test6_onboard() throws Exception { JsonOnboard jsonOnboard
1927 * = new JsonOnboard(); jsonOnboard.setAppname("TestApp2");
1928 * jsonOnboard.setIsAAF("false"); jsonOnboard.setUserId("TestUser2");
1929 * jsonOnboard.setPassword("TestPassword2");
1931 * @SuppressWarnings("unchecked") Map<String, Object> resultMap = (Map<String,
1933 * admin.onboardAppWithMusic(jsonOnboard,adminAuthorization).getEntity();
1934 * resultMap.containsKey("success"); onboardUUID =
1935 * resultMap.get("Generated AID").toString();
1936 * assertEquals("Your application TestApp2 has been onboarded with MUSIC.",
1937 * resultMap.get("Success")); }
1941 public void Test6_onboard_duplicate() throws Exception {
1942 JsonOnboard jsonOnboard = new JsonOnboard();
1943 jsonOnboard.setAppname("TestApp2");
1944 jsonOnboard.setIsAAF("false");
1945 jsonOnboard.setUserId("TestUser2");
1946 jsonOnboard.setPassword("TestPassword2");
1947 Response response = admin.onboardAppWithMusic(jsonOnboard,adminAuthorization);
1948 assertEquals(204, response.getStatus());
1953 public void Test6_onboard1() throws Exception {
1954 JsonOnboard jsonOnboard = new JsonOnboard();
1955 jsonOnboard.setIsAAF("false");
1956 jsonOnboard.setUserId("TestUser2");
1957 jsonOnboard.setPassword("TestPassword2");
1958 Map<String, Object> resultMap = (Map<String, Object>) admin.onboardAppWithMusic(jsonOnboard,adminAuthorization).getEntity();
1959 // assertTrue(resultMap.containsKey("error"));
1960 //System.out.println("--->" + resultMap.toString());
1961 //assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
1966 public void Test7_onboardSearch() throws Exception {
1967 JsonOnboard jsonOnboard = new JsonOnboard();
1968 jsonOnboard.setAppname("TestApp2");
1969 jsonOnboard.setIsAAF("false");
1970 jsonOnboard.setAid(onboardUUID);
1971 Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard,adminAuthorization).getEntity();
1972 resultMap.containsKey("success");
1973 assertEquals(null, resultMap.get(onboardUUID));
1978 public void Test7_onboardSearch1() throws Exception {
1979 JsonOnboard jsonOnboard = new JsonOnboard();
1980 jsonOnboard.setIsAAF("false");
1981 jsonOnboard.setAid(onboardUUID);
1982 Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard,adminAuthorization).getEntity();
1983 System.out.println("--->" + resultMap.toString());
1984 resultMap.containsKey("success");
1985 assertEquals(null, resultMap.get(onboardUUID));
1989 public void Test7_onboardSearch_empty() throws Exception {
1990 JsonOnboard jsonOnboard = new JsonOnboard();
1991 Response response = admin.getOnboardedInfoSearch(jsonOnboard,adminAuthorization);
1992 // assertEquals(400, response.getStatus());
1996 public void Test7_onboardSearch_invalidAid() throws Exception {
1997 JsonOnboard jsonOnboard = new JsonOnboard();
1998 jsonOnboard.setAppname("TestApp2");
1999 jsonOnboard.setIsAAF("false");
2000 jsonOnboard.setAid("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
2001 Response response = admin.getOnboardedInfoSearch(jsonOnboard,adminAuthorization);
2002 // assertEquals(400, response.getStatus());
2006 public void Test8_onboardUpdate() throws Exception {
2007 JsonOnboard jsonOnboard = new JsonOnboard();
2008 jsonOnboard.setIsAAF("false");
2009 jsonOnboard.setUserId("TestUser3");
2010 jsonOnboard.setPassword("TestPassword3");
2011 jsonOnboard.setAid(onboardUUID);
2012 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard,adminAuthorization).getEntity();
2013 System.out.println("--->" + resultMap.toString());
2014 resultMap.containsKey("success");
2015 assertNotNull(resultMap);
2020 public void Test8_onboardUpdate1() throws Exception {
2021 JsonOnboard jsonOnboard = new JsonOnboard();
2022 jsonOnboard.setIsAAF("false");
2023 jsonOnboard.setUserId("TestUser3");
2024 jsonOnboard.setPassword("TestPassword3");
2025 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard,adminAuthorization).getEntity();
2026 System.out.println("--->" + resultMap.toString());
2027 assertNotNull(resultMap);
2032 public void Test8_onboardUpdate2() throws Exception {
2033 JsonOnboard jsonOnboard = new JsonOnboard();
2034 jsonOnboard.setAppname("TestApp2");
2035 jsonOnboard.setIsAAF("false");
2036 jsonOnboard.setUserId("TestUser3");
2037 jsonOnboard.setPassword("TestPassword3");
2038 jsonOnboard.setAid(onboardUUID);
2039 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard,adminAuthorization).getEntity();
2040 assertNotNull(resultMap);
2045 public void Test8_onboardUpdate3() throws Exception {
2046 JsonOnboard jsonOnboard = new JsonOnboard();
2047 jsonOnboard.setAid(onboardUUID);
2048 Map<String, Object> resultMap = (Map<String, Object>) admin.updateOnboardApp(jsonOnboard,adminAuthorization).getEntity();
2049 assertNotNull(resultMap);
2053 public void Test9_onboardDelete() throws Exception {
2054 JsonOnboard jsonOnboard = new JsonOnboard();
2055 jsonOnboard.setAppname("TestApp2");
2056 jsonOnboard.setAid(onboardUUID);
2057 Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard,adminAuthorization).getEntity();
2058 resultMap.containsKey("success");
2059 assertNotNull(resultMap);
2063 public void Test9_onboardDelete1() throws Exception {
2064 JsonOnboard jsonOnboard = new JsonOnboard();
2065 Map<String, Object> resultMap = (Map<String, Object>) admin.deleteOnboardApp(jsonOnboard,adminAuthorization).getEntity();
2066 assertNotNull(resultMap);
2070 public void Test3_createLockReference() throws Exception {
2071 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2072 Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1",authorization, null, appName).getEntity();
2074 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2078 public void Test3_createLockReference_invalidLock() throws Exception {
2079 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2080 if (lock.createLockReference("lockName","1","1",authorization, null, appName).getEntity() == null) {
2081 System.err.println("yo");
2084 Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference("lockName","1","1",authorization, null, appName).getEntity();
2085 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2089 public void Test3_createLockReference_invalidAuthorization() throws Exception {
2090 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2091 Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1",wrongAuthorization, null, appName).getEntity();
2092 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2096 public void Test4_accquireLock() throws Exception {
2097 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2098 Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLock(lockName,"1","1",authorization, null, appName).getEntity();
2100 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2104 * @Test public void Test4_accquireLock_wrongAuthorization() throws Exception {
2105 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
2106 * MusicUtil.getVersion()); Map<String, Object> resultMap = (Map<String,
2107 * Object>) lock.accquireLock(Mockito.anyString(),"1","1",wrongAuthorization,
2108 * null, appName).getEntity(); assertEquals(ResultType.FAILURE,
2109 * resultMap.get("status")); }
2113 * @Test public void Test5_accquireLockwithLease() throws Exception {
2114 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
2115 * MusicUtil.getVersion()); JsonLeasedLock leasedLock = new JsonLeasedLock();
2116 * leasedLock.setLeasePeriod(1000l); Map<String, Object> resultMap =
2117 * (Map<String, Object>)
2118 * lock.accquireLockWithLease(leasedLock,lockId,"1","1",authorization, null,
2119 * appName).getEntity(); assertEquals(ResultType.SUCCESS,
2120 * resultMap.get("status")); }
2124 public void Test5_accquireLockwithLease_invalidLock() throws Exception {
2125 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2126 JsonLeasedLock leasedLock = new JsonLeasedLock();
2127 leasedLock.setLeasePeriod(1000l);
2128 Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLockWithLease(leasedLock,"lockId","1","1",authorization, null, appName).getEntity();
2129 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2134 * @Test public void Test5_currentLockHolder() throws Exception {
2135 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
2136 * MusicUtil.getVersion()); Map<String, Object> resultMap = (Map<String,
2137 * Object>) lock.currentLockHolder(lockName,"1","1",authorization, null,
2138 * appName).getEntity(); assertEquals(ResultType.SUCCESS,
2139 * resultMap.get("status")); }
2143 public void Test5_currentLockHolder_invalidLock() throws Exception {
2144 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2145 Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder("lockName","1","1",authorization, null, appName).getEntity();
2146 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2150 public void Test5_currentLockHolder_wrongAuthorization() throws Exception {
2151 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2152 Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder(lockName,"1","1",wrongAuthorization, null, appName).getEntity();
2153 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2157 public void Test6_currentLockState() throws Exception {
2158 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2159 Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockState(lockName,"1","1",authorization, null, appName).getEntity();
2161 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2165 public void Test6_currentLockState_invalidLock() throws Exception {
2166 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2167 Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockState("lockName","1","1",authorization, null, appName).getEntity();
2168 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2172 public void Test6_currentLockState_wrongAuthorization() throws Exception {
2173 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2174 Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockState(lockName,"1","1",wrongAuthorization, null, appName).getEntity();
2175 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2179 * @Test public void Test7_unLock() throws Exception {
2180 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
2181 * MusicUtil.getVersion()); Map<String, Object> resultMap = (Map<String,
2182 * Object>) lock.unLock(lockId,"1","1",authorization, null,
2183 * appName).getEntity(); assertEquals(ResultType.SUCCESS,
2184 * resultMap.get("status")); }
2188 * @Test public void Test7_unLock_invalidLock() throws Exception {
2189 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
2190 * MusicUtil.getVersion()); Map<String, Object> resultMap = (Map<String,
2191 * Object>) lock.unLock("lockId","1","1",authorization, null,
2192 * appName).getEntity(); assertEquals(ResultType.FAILURE,
2193 * resultMap.get("status")); }
2196 * @Test public void Test7_unLock_wrongAUthorization() throws Exception {
2197 * Mockito.doNothing().when(http).addHeader(xLatestVersion,
2198 * MusicUtil.getVersion()); Map<String, Object> resultMap = (Map<String,
2199 * Object>) lock.unLock(lockId,"1","1",wrongAuthorization, null,
2200 * appName).getEntity(); assertEquals(ResultType.FAILURE,
2201 * resultMap.get("status")); }
2205 public void Test8_delete() throws Exception {
2206 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2207 Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null,authorization, appName).getEntity();
2208 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2212 public void Test8_delete_invalidLock() throws Exception {
2213 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2214 Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock("lockName","1","1", null,authorization, appName).getEntity();
2215 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2219 public void Test8_delete_wrongAuthorization() throws Exception {
2220 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2221 Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null,wrongAuthorization, appName).getEntity();
2222 assertEquals(ResultType.FAILURE, resultMap.get("status"));
2226 public void Test1_version( ) {
2227 RestMusicVersionAPI versionapi = new RestMusicVersionAPI();
2228 HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
2229 Map<String, Object> resultMap = versionapi.version(servletResponse);
2230 assertEquals(ResultType.SUCCESS, resultMap.get("status"));
2235 public void Test2_testAPI() {
2236 RestMusicTestAPI musicTest = new RestMusicTestAPI();
2237 HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
2238 Map<String, HashMap<String, String>> resultMap = musicTest.simpleTests(servletResponse);
2239 assertNotNull(resultMap);
2242 //Music Health Check
2244 public void Test3_HealthCheck_cassandra() {
2245 String consistency = "ONE";
2246 RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
2247 HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
2248 Response response = healthCheck.cassandraStatus(servletResponse, consistency);
2249 assertEquals(200, response.getStatus());
2253 public void Test3_HealthCheck_cassandra_cosistencyQuorum() {
2254 String consistency = "QUORUM";
2255 RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
2256 HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
2257 Response response = healthCheck.cassandraStatus(servletResponse, consistency);
2258 assertEquals(200, response.getStatus());
2262 public void Test3_HealthCheck_zookeeper() {
2263 RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
2264 HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
2265 Response response = healthCheck.ZKStatus(servletResponse);
2266 assertEquals(200, response.getStatus());
2270 public void Test4_pureZKcreate() throws Exception {
2271 RestMusicBmAPI bmApi = new RestMusicBmAPI();
2272 bmApi.pureZkCreate("sample");
2276 public void Test4_pureZKUpdate() throws Exception {
2277 RestMusicBmAPI bmApi = new RestMusicBmAPI();
2278 bmApi.pureZkCreate("sample1");
2279 JsonInsert jsonInsert = new JsonInsert();
2280 Map<String, String> consistencyInfo = new HashMap<>();
2281 Map<String, Object> values = new HashMap<>();
2282 values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
2283 values.put("emp_name", "testName_create");
2284 values.put("emp_salary", 500);
2285 consistencyInfo.put("type", "eventual");
2286 jsonInsert.setConsistencyInfo(consistencyInfo);
2287 jsonInsert.setKeyspaceName(keyspaceName);
2288 jsonInsert.setTableName(tableName);
2289 jsonInsert.setValues(values);
2290 bmApi.pureZkUpdate(jsonInsert, "sampleNode1");
2294 public void Test4_pureZKGet() throws Exception {
2295 RestMusicBmAPI bmApi = new RestMusicBmAPI();
2296 bmApi.pureZkGet("sample");
2300 * @Test public void Test5_ZKAtomicPut_atomic() throws Exception {
2301 * RestMusicBmAPI bmApi = new RestMusicBmAPI(); JsonInsert jsonInsert = new
2302 * JsonInsert(); Map<String, String> consistencyInfo = new HashMap<>();
2303 * Map<String, Object> values = new HashMap<>(); values.put("uuid",
2304 * "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); values.put("emp_name",
2305 * "testName_create"); values.put("emp_salary", 1500);
2306 * consistencyInfo.put("type", "atomic");
2307 * jsonInsert.setConsistencyInfo(consistencyInfo);
2308 * jsonInsert.setKeyspaceName(keyspaceName); jsonInsert.setTableName(tableName);
2309 * jsonInsert.setValues(values); bmApi.pureZkAtomicPut(jsonInsert, lockName,
2313 * @Test public void Test5_ZKAtomicPut_atomic_with_delete() throws Exception {
2314 * RestMusicBmAPI bmApi = new RestMusicBmAPI(); JsonInsert jsonInsert = new
2315 * JsonInsert(); Map<String, String> consistencyInfo = new HashMap<>();
2316 * Map<String, Object> values = new HashMap<>(); values.put("uuid",
2317 * "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); values.put("emp_name",
2318 * "testName_create"); values.put("emp_salary", 1500);
2319 * consistencyInfo.put("type", "atomic_delete_lock");
2320 * jsonInsert.setConsistencyInfo(consistencyInfo);
2321 * jsonInsert.setKeyspaceName(keyspaceName); jsonInsert.setTableName(tableName);
2322 * jsonInsert.setValues(values); bmApi.pureZkAtomicPut(jsonInsert, lockName,
2327 * @Test public void Test5_ZKAtomicGet_atomic() throws Exception {
2328 * RestMusicBmAPI bmApi = new RestMusicBmAPI(); JsonInsert jsonInsert = new
2329 * JsonInsert(); Map<String, String> consistencyInfo = new HashMap<>();
2330 * Map<String, Object> values = new HashMap<>(); values.put("uuid",
2331 * "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); values.put("emp_name",
2332 * "testName_create"); values.put("emp_salary", 1500);
2333 * consistencyInfo.put("type", "atomic_delete_lock");
2334 * jsonInsert.setConsistencyInfo(consistencyInfo);
2335 * jsonInsert.setKeyspaceName(keyspaceName); jsonInsert.setTableName(tableName);
2336 * jsonInsert.setValues(values); bmApi.pureZkAtomicGet(jsonInsert, lockName,
2341 * @Test public void Test5_ZKAtomicGet_atomic_with_delete() throws Exception {
2342 * RestMusicBmAPI bmApi = new RestMusicBmAPI(); JsonInsert jsonInsert = new
2343 * JsonInsert(); Map<String, String> consistencyInfo = new HashMap<>();
2344 * Map<String, Object> values = new HashMap<>(); values.put("uuid",
2345 * "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); values.put("emp_name",
2346 * "testName_create"); values.put("emp_salary", 1500);
2347 * consistencyInfo.put("type", "atomic_delete_lock");
2348 * jsonInsert.setConsistencyInfo(consistencyInfo);
2349 * jsonInsert.setKeyspaceName(keyspaceName); jsonInsert.setTableName(tableName);
2350 * jsonInsert.setValues(values); bmApi.pureZkAtomicGet(jsonInsert, lockName,
2355 public void Test5_updateCassa() throws Exception {
2356 RestMusicBmAPI bmApi = new RestMusicBmAPI();
2357 JsonInsert jsonInsert = new JsonInsert();
2358 Map<String, String> consistencyInfo = new HashMap<>();
2359 Map<String, Object> values = new HashMap<>();
2360 values.put("emp_salary", 1500);
2361 consistencyInfo.put("type", "eventual");
2362 jsonInsert.setConsistencyInfo(consistencyInfo);
2363 jsonInsert.setKeyspaceName(keyspaceName);
2364 jsonInsert.setTableName(tableName);
2365 jsonInsert.setValues(values);
2366 MultivaluedMap<String, String> row = new MultivaluedMapImpl();
2367 row.add("emp_name", "testName_create");
2368 Mockito.when(info.getQueryParameters()).thenReturn(row);
2369 //bmApi.updateTableCassa(jsonInsert, keyspaceName, tableName, info);
2372 // RestMusicConditional
2374 public void Test5_createTable_conditional() throws Exception {
2375 JsonTable jsonTable = new JsonTable();
2376 Map<String, String> consistencyInfo = new HashMap<>();
2377 Map<String, String> fields = new HashMap<>();
2378 fields.put("id", "text");
2379 fields.put("plans", "Map<text,text>");
2380 fields.put("PRIMARY KEY", "(id)");
2381 consistencyInfo.put("type", "eventual");
2382 jsonTable.setConsistencyInfo(consistencyInfo);
2383 jsonTable.setKeyspaceName(keyspaceName);
2384 jsonTable.setPrimaryKey("id");
2385 jsonTable.setTableName(tableNameConditional);
2386 jsonTable.setFields(fields);
2387 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2388 Response response = data.createTable("1", "1", "1",
2389 "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
2390 jsonTable, keyspaceName, tableNameConditional);
2391 System.out.println("#######status is " + response.getStatus());
2392 System.out.println("Entity" + response.getEntity());
2393 //assertEquals(200, response.getStatus());
2394 assertEquals(401, response.getStatus());
2398 public void Test6_insertConditional() throws Exception {
2399 RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2400 JsonConditional json = new JsonConditional();
2401 json.setPrimaryKey("id");
2402 json.setPrimaryKeyValue("123|abc|port");
2403 json.setCasscadeColumnName("plans");
2404 Map<String, Object> tableValues = new HashMap<>();
2405 tableValues.put("id", "123|abc|port");
2406 json.setTableValues(tableValues);
2407 Map<String, Object> columnData = new HashMap<>();
2408 Map<String, String> column = new HashMap<>();
2409 column.put("created", "time");
2410 columnData.put("key", "P2");
2411 columnData.put("value", column);
2412 json.setCasscadeColumnData(columnData);
2413 Map<String, String> cond = new HashMap<>();
2414 Map<String, String> cond1 = new HashMap<>();
2415 Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2416 cond.put("status", "under-spin-up");
2417 cond1.put("status", "parked");
2418 conditions.put("exists", cond);
2419 conditions.put("nonexists", cond1);
2420 json.setConditions(conditions);
2421 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2422 Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2423 appName, authorization, keyspaceName, tableNameConditional, json);
2424 assertEquals(401, response.getStatus());
2428 public void Test6_insertConditional_primaryKey_null() throws Exception {
2429 RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2430 JsonConditional json = new JsonConditional();
2431 json.setPrimaryKeyValue("123|abc|port");
2432 json.setCasscadeColumnName("plans");
2433 Map<String, Object> tableValues = new HashMap<>();
2434 tableValues.put("id", "123|abc|port");
2435 json.setTableValues(tableValues);
2436 Map<String, Object> columnData = new HashMap<>();
2437 Map<String, String> column = new HashMap<>();
2438 column.put("created", "time");
2439 columnData.put("key", "P2");
2440 columnData.put("value", column);
2441 json.setCasscadeColumnData(columnData);
2442 Map<String, String> cond = new HashMap<>();
2443 Map<String, String> cond1 = new HashMap<>();
2444 Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2445 cond.put("status", "under-spin-up");
2446 cond1.put("status", "parked");
2447 conditions.put("exists", cond);
2448 conditions.put("nonexists", cond1);
2449 json.setConditions(conditions);
2450 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2451 Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2452 appName, authorization, keyspaceName, tableNameConditional, json);
2453 assertEquals(401, response.getStatus());
2457 public void Test6_insertConditional_wrongAuth() throws Exception {
2458 RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2459 JsonConditional json = new JsonConditional();
2460 json.setPrimaryKey("id");
2461 json.setPrimaryKeyValue("123|abc|port");
2462 json.setCasscadeColumnName("plans");
2463 Map<String, Object> tableValues = new HashMap<>();
2464 tableValues.put("id", "123|abc|port");
2465 json.setTableValues(tableValues);
2466 Map<String, Object> columnData = new HashMap<>();
2467 Map<String, String> column = new HashMap<>();
2468 column.put("created", "time");
2469 columnData.put("key", "P2");
2470 columnData.put("value", column);
2471 json.setCasscadeColumnData(columnData);
2472 Map<String, String> cond = new HashMap<>();
2473 Map<String, String> cond1 = new HashMap<>();
2474 Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2475 cond.put("status", "under-spin-up");
2476 cond1.put("status", "parked");
2477 conditions.put("exists", cond);
2478 conditions.put("nonexists", cond1);
2479 json.setConditions(conditions);
2480 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2481 Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2482 appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
2483 assertEquals(401, response.getStatus());
2487 public void Test7_updateConditional() throws Exception {
2488 RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2489 JsonConditional json = new JsonConditional();
2490 json.setPrimaryKey("id");
2491 json.setPrimaryKeyValue("123|abc|port");
2492 json.setCasscadeColumnName("plans");
2493 Map<String, Object> tableValues = new HashMap<>();
2494 tableValues.put("id", "123|abc|port");
2495 json.setTableValues(tableValues);
2496 Map<String, Object> columnData = new HashMap<>();
2497 Map<String, String> column = new HashMap<>();
2498 column.put("created", "time");
2499 columnData.put("key", "P2");
2500 columnData.put("value", column);
2501 json.setCasscadeColumnData(columnData);
2502 Map<String, String> cond = new HashMap<>();
2503 Map<String, String> cond1 = new HashMap<>();
2504 Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2505 cond.put("updated", "new time");
2506 conditions.put("exists", cond);
2507 conditions.put("nonexists", cond1);
2508 json.setConditions(conditions);
2509 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2510 Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2511 appName, authorization, keyspaceName, tableNameConditional, json);
2512 assertEquals(401, response.getStatus());
2516 public void Test7_updateConditional_wrongAuth() throws Exception {
2517 RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2518 JsonConditional json = new JsonConditional();
2519 json.setPrimaryKey("id");
2520 json.setPrimaryKeyValue("123|abc|port");
2521 json.setCasscadeColumnName("plans");
2522 Map<String, Object> tableValues = new HashMap<>();
2523 tableValues.put("id", "123|abc|port");
2524 json.setTableValues(tableValues);
2525 Map<String, Object> columnData = new HashMap<>();
2526 Map<String, String> column = new HashMap<>();
2527 column.put("created", "time");
2528 columnData.put("key", "P2");
2529 columnData.put("value", column);
2530 json.setCasscadeColumnData(columnData);
2531 Map<String, String> cond = new HashMap<>();
2532 Map<String, String> cond1 = new HashMap<>();
2533 Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2534 cond.put("updated", "new time");
2535 conditions.put("exists", cond);
2536 conditions.put("nonexists", cond1);
2537 json.setConditions(conditions);
2538 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2539 Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2540 appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
2541 assertEquals(401, response.getStatus());
2545 public void Test7_updateConditional_primarykey_null() throws Exception {
2546 RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
2547 JsonConditional json = new JsonConditional();
2548 json.setPrimaryKeyValue("123|abc|port");
2549 json.setCasscadeColumnName("plans");
2550 Map<String, Object> tableValues = new HashMap<>();
2551 tableValues.put("id", "123|abc|port");
2552 json.setTableValues(tableValues);
2553 Map<String, Object> columnData = new HashMap<>();
2554 Map<String, String> column = new HashMap<>();
2555 column.put("created", "time");
2556 columnData.put("key", "P2");
2557 columnData.put("value", column);
2558 json.setCasscadeColumnData(columnData);
2559 Map<String, String> cond = new HashMap<>();
2560 Map<String, String> cond1 = new HashMap<>();
2561 Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
2562 cond.put("updated", "new time");
2563 conditions.put("exists", cond);
2564 conditions.put("nonexists", cond1);
2565 json.setConditions(conditions);
2566 Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
2567 Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
2568 appName, authorization, keyspaceName, tableNameConditional, json);
2569 assertEquals(401, response.getStatus());