summaryrefslogtreecommitdiffstats
path: root/src/test/java/org
diff options
context:
space:
mode:
authorThomas Nelson Jr (arthurdent3) tn1381@att.com <tn1381@att.com>2018-07-16 16:41:20 -0400
committerThomas Nelson Jr (arthurdent3) tn1381@att.com <tn1381@att.com>2018-07-16 16:41:20 -0400
commit9b6efbd93a12c858a0d2643013217ec3d6c3a46d (patch)
treebaf6c8de19daba3f4dc2b7761bda4cb858ba90e4 /src/test/java/org
parent5a28a331688c5578fef9c64d462d07cbae6797da (diff)
various Updates
Q-api, triggers, conductor conditional updates. Bug fixes Change-Id: Iec392309787cd90f0a2827a2955399723640e800 Issue-ID: MUSIC-93 Signed-off-by: Thomas Nelson Jr (arthurdent3) tn1381@att.com <tn1381@att.com>
Diffstat (limited to 'src/test/java/org')
-rw-r--r--src/test/java/org/onap/music/unittests/TestMusicCore.java197
-rw-r--r--src/test/java/org/onap/music/unittests/TestRestMusicData.java1621
-rw-r--r--src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java1031
3 files changed, 2798 insertions, 51 deletions
diff --git a/src/test/java/org/onap/music/unittests/TestMusicCore.java b/src/test/java/org/onap/music/unittests/TestMusicCore.java
index d1da3195..ed9c2f68 100644
--- a/src/test/java/org/onap/music/unittests/TestMusicCore.java
+++ b/src/test/java/org/onap/music/unittests/TestMusicCore.java
@@ -24,9 +24,11 @@ package org.onap.music.unittests;
import static org.junit.Assert.*;
import static org.onap.music.main.MusicCore.mDstoreHandle;
import static org.onap.music.main.MusicCore.mLockHandle;
-
+import java.util.HashMap;
+import java.util.Map;
import org.apache.zookeeper.KeeperException.NoNodeException;
import org.junit.Before;
+import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
@@ -45,6 +47,11 @@ import org.onap.music.main.ReturnType;
import org.onap.music.main.MusicCore.Condition;
import org.onap.music.datastore.MusicDataStore;
import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.eelf.logging.EELFLoggerDelegate;
+import org.onap.music.eelf.logging.format.AppMessages;
+import org.onap.music.eelf.logging.format.ErrorSeverity;
+import org.onap.music.eelf.logging.format.ErrorTypes;
+import com.att.eelf.exception.EELFException;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Session;
@@ -77,6 +84,16 @@ public class TestMusicCore {
Mockito.verify(mLockHandle).createLockId("/" + "test");
}
+
+ @Test
+ public void testCreateLockReferencefornullname() {
+ Mockito.when(mLockHandle.createLockId("/" + "test")).thenReturn("lock");
+ String lockId = MusicCore.createLockReference("x"); //test");
+ //System.out.println("cjc exception lockhandle=" + mLockHandle+"lockid="+lockId );
+ assertNotEquals("lock", lockId);
+ //Mockito.verify(mLockHandle).createLockId("/" + "test");
+ }
+
@Test
public void testIsTableOrKeySpaceLock() {
Boolean result = MusicCore.isTableOrKeySpaceLock("ks1.tn1");
@@ -136,11 +153,11 @@ public class TestMusicCore {
@Test
public void testAcquireLockifisMyTurnTrueandIsTableOrKeySpaceLockFalseandDontHaveLock() throws MusicLockingException {
MusicLockState musicLockState = new MusicLockState(LockStatus.LOCKED, "id2");
- Mockito.when(mLockHandle.isMyTurn("id2")).thenReturn(true);
+ Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(true);
Mockito.when(mLockHandle.getLockState("ks1.tn1.pk1")).thenReturn(musicLockState);
- ReturnType lock = MusicCore.acquireLock("ks1.tn1.pk1", "id2");
+ ReturnType lock = MusicCore.acquireLock("ks1.tn1.pk1", "id1");
assertEquals(lock.getResult(), ResultType.SUCCESS);
- Mockito.verify(mLockHandle).isMyTurn("id2");
+ Mockito.verify(mLockHandle).isMyTurn("id1");
Mockito.verify(mLockHandle).getLockState("ks1.tn1.pk1");
}
@@ -486,4 +503,176 @@ public class TestMusicCore {
.getLockState("ks1" + "." + "tn1" + "." + "pk1");
}
+ @Test
+ public void testAtomicGetPreparedQuerywithDeleteLockWithLeaseFalse()
+ throws MusicServiceException, MusicLockingException {
+ mDstoreHandle = Mockito.mock(MusicDataStore.class);
+ preparedQueryObject = Mockito.mock(PreparedQueryObject.class);
+ rs = Mockito.mock(ResultSet.class);
+ Mockito.when(mLockHandle.createLockId("/" + "ks1.tn1.pk1")).thenReturn("id1");
+ Mockito.when(mLockHandle.isMyTurn("id1")).thenReturn(false);
+ ResultSet rs1 = MusicCore.atomicGet("ks1", "tn1", "pk1", preparedQueryObject);
+ assertNull(rs1);
+ Mockito.verify(mLockHandle).createLockId("/" + "ks1.tn1.pk1");
+ Mockito.verify(mLockHandle).isMyTurn("id1");
+ }
+
+ @Test
+ public void testCondition() throws Exception {
+ //Condition conClass = Mockito.mock(Condition.class);
+ // boolean ret=true;
+ //Mockito.when(conClass.testCondition().thenReturn(ret);
+ Map<String, Object> conditionsx=null;
+ PreparedQueryObject selectQueryForTheRowx=null;
+ try {
+ Condition con = new Condition(conditionsx,selectQueryForTheRowx);
+ assertTrue(con.testCondition());
+ } catch (Exception e) {
+ assertFalse(false);
+ }
+ }
+ //getLockingServiceHandl
+
+ @Ignore
+ @Test(expected = MusicLockingException.class) //("Failed to aquire Locl store handle " + e))
+ public void testgetLockingServiceHandle() throws Exception {
+ // MusicLockingService mLockHandlex = Mockito.mock(MusicLockingService.class);
+ //MusicLockingService mLockHandlea = mLockHandle;
+ //mLockHandle=null;
+ System.out.println("cjc 0 locking test n");
+ // Mockito.when(MusicCore.getLockingServiceHandle()).thenReturn(mLockHandle);
+ //mLockHandle=null;
+ //System.out.println("cjc 0-1 locking test n");
+ MusicLockingService mLockHandlea = mLockHandle;
+ mLockHandle=null;
+
+ MusicLockingService mLockHandley=null; //MusicCore.getLockingServiceHandle();
+ Mockito.when(MusicCore.getLockingServiceHandle()).thenReturn(mLockHandley);
+ System.out.println("cjc locking test n");
+ mLockHandle=mLockHandlea;
+ assertTrue(true);
+
+ }
+
+ @Test(expected = MusicServiceException.class)
+ public void testGetDSHandle() throws MusicServiceException, MusicQueryException {
+ // rs = Mockito.mock(ResultSet.class);
+ // session = Mockito.mock(Session.class);
+ //Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+ //Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
+
+ MusicDataStore mDstoreHandlea = Mockito.mock(MusicDataStore.class);
+ //MusicUtil mMusicUtil=Mockito.mock(MusicUtil.class);
+ //System.out.println("cjc 0 getDsHandle");
+ Mockito.when(MusicCore.getDSHandle()).thenReturn(mDstoreHandlea);
+ // System.out.println("cjc localhost");
+ // Mockito.when(mMusicUtil.getMyCassaHost().equals("localhost")).thenReturn(null);
+ //System.out.println("cjc 1 localhost");
+ // mDstoreHandle = new MusicDataStore(MusicUtil.getMyCassaHost());
+ // } else {
+ // mDstoreHandle = new MusicDataStore();
+ // }
+ assertTrue(true);
+ }
+
+ //add mocking
+ @Ignore
+ @Test
+ public void testGetDSHandleIp() throws MusicServiceException, MusicQueryException {
+ // rs = Mockito.mock(ResultSet.class);
+ // session = Mockito.mock(Session.class);
+ //Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+ //Mockito.when(mDstoreHandle.executeCriticalGet(preparedQueryObject)).thenReturn(rs);
+
+ //mDstoreHandle = Mockito.mock(MusicDataStore.class);
+ //MusicUtil mMusicUtil=Mockito.mock(MusicUtil.class);
+ System.out.println("cjc 0 getDsHandleIP");
+ Mockito.when(MusicCore.getDSHandle("1.127.0.1")).thenReturn(mDstoreHandle);
+ System.out.println("cjc localhost");
+ // Mockito.when(mMusicUtil.getMyCassaHost().equals("localhost")).thenReturn(null);
+ System.out.println("cjc 1 localhost IP");
+ // mDstoreHandle = new MusicDataStore(MusicUtil.getMyCassaHost());
+ // } else {
+ // mDstoreHandle = new MusicDataStore();
+ // }
+ assertTrue(true);
+ }
+
+ @Ignore
+ @Test
+ public void testPureZkCreate() {
+ try {
+ MusicCore.pureZkCreate("local");
+ } catch(NullPointerException e) {
+ System.out.println("cjc zkcreate null pointwer exception:"+ e);
+ }
+ }
+
+ @Ignore
+ @Test
+ public void testPureZkRead() { //String nodeName) {
+ byte[] data = MusicCore.pureZkRead("localhost");
+ }
+
+ //need fixing
+ @Ignore
+ @Test
+ public void testPureZkWrite() { //String nodeName, byte[] data) {
+ /*
+ long start = System.currentTimeMillis();
+ logger.info(EELFLoggerDelegate.applicationLogger,"Performing zookeeper write to " + nodeName);
+ try {
+ getLockingServiceHandle().getzkLockHandle().setNodeData(nodeName, data);
+ } catch (MusicLockingException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), "[ERR512E] Failed to get ZK Lock Handle " ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
+ }
+ logger.info(EELFLoggerDelegate.applicationLogger,"Performed zookeeper write to " + nodeName);
+ long end = System.currentTimeMillis();
+ logger.info(EELFLoggerDelegate.applicationLogger,"Time taken for the actual zk put:" + (end - start) + " ms");
+ */
+
+ // mDstoreHandle = Mockito.mock(MusicDataStore.class);
+ // rs = Mockito.mock(ResultSet.class);
+ // session = Mockito.mock(Session.class);
+ //Mockito.when(mDstoreHandle.getSession()).thenReturn(session);
+
+ byte[] data= "Testing Zoo Keeper".getBytes();
+ MusicCore.pureZkWrite("1.127.0.1", data);
+ // assertNotNull(rs1);
+ }
+
+ @Test
+ public void testWhoseTurnIsIt() { //(String lockName) {
+
+ /*
+ try {
+ return getLockingServiceHandle().whoseTurnIsIt("/" + lockName) + "";
+ } catch (MusicLockingException e) {
+ logger.error(EELFLoggerDelegate.errorLogger,e.getMessage(), AppMessages.LOCKINGERROR+lockName ,ErrorSeverity.CRITICAL, ErrorTypes.LOCKINGERROR);
+ }
+ return null;
+ */
+
+ String lockName="xxx";
+ if (MusicCore.whoseTurnIsIt(lockName) != null) assertTrue(true);
+
+
+
+ }
+
+ @Test
+ public void testMarshallResults() {
+ Map<String, HashMap<String, Object>> ret=null;
+ //ResultSet results =null;
+ rs = Mockito.mock(ResultSet.class);
+ try {
+ ret= MusicCore.marshallResults(rs);
+
+ } catch( Exception e ) {
+
+ }
+
+ if (ret != null) assertTrue(true);
+ }
+
}
diff --git a/src/test/java/org/onap/music/unittests/TestRestMusicData.java b/src/test/java/org/onap/music/unittests/TestRestMusicData.java
index 4234c88e..e18982e5 100644
--- a/src/test/java/org/onap/music/unittests/TestRestMusicData.java
+++ b/src/test/java/org/onap/music/unittests/TestRestMusicData.java
@@ -19,8 +19,13 @@ package org.onap.music.unittests;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
+import static org.onap.music.main.MusicCore.mLockHandle;
+
import java.io.File;
+import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -30,15 +35,22 @@ import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.UriInfo;
import org.apache.curator.test.TestingServer;
+import org.apache.http.impl.client.AutoRetryHttpClient;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.MethodSorters;
+import org.mindrot.jbcrypt.BCrypt;
+import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.music.conductor.conditionals.JsonConditional;
+import org.onap.music.conductor.conditionals.MusicConditional;
+import org.onap.music.conductor.conditionals.RestMusicConditionalAPI;
import org.onap.music.datastore.PreparedQueryObject;
import org.onap.music.datastore.jsonobjects.JsonDelete;
import org.onap.music.datastore.jsonobjects.JsonInsert;
@@ -47,16 +59,28 @@ import org.onap.music.datastore.jsonobjects.JsonOnboard;
import org.onap.music.datastore.jsonobjects.JsonSelect;
import org.onap.music.datastore.jsonobjects.JsonTable;
import org.onap.music.datastore.jsonobjects.JsonUpdate;
+import org.onap.music.exceptions.MusicServiceException;
+import org.onap.music.lockingservice.MusicLockState;
import org.onap.music.lockingservice.MusicLockingService;
+import org.onap.music.lockingservice.MusicLockState.LockStatus;
+import org.onap.music.main.CachingUtil;
import org.onap.music.main.MusicCore;
import org.onap.music.main.MusicUtil;
import org.onap.music.main.ResultType;
+import org.onap.music.main.ReturnType;
import org.onap.music.rest.RestMusicAdminAPI;
+import org.onap.music.rest.RestMusicBmAPI;
import org.onap.music.rest.RestMusicDataAPI;
+import org.onap.music.rest.RestMusicHealthCheckAPI;
import org.onap.music.rest.RestMusicLocksAPI;
+import org.onap.music.rest.RestMusicTestAPI;
+import org.onap.music.rest.RestMusicVersionAPI;
+
+import com.datastax.driver.core.ConsistencyLevel;
import com.datastax.driver.core.DataType;
import com.datastax.driver.core.ResultSet;
import com.datastax.driver.core.Row;
+import com.sun.jersey.core.util.Base64;
import com.sun.jersey.core.util.MultivaluedMapImpl;
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
@@ -75,13 +99,26 @@ public class TestRestMusicData {
@Mock
UriInfo info;
+ //* cjc out
+ @Mock
+ CachingUtil cachUtilMock;
+
+ @InjectMocks
+ private MusicCore mCore;
+ //*/
+
static String appName = "TestApp";
static String userId = "TestUser";
static String password = "TestPassword";
+ static String authData = userId+":"+password;
+ static String wrongAuthData = userId+":"+"pass";
+ static String authorization = new String(Base64.encode(authData.getBytes()));
+ static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
static boolean isAAF = false;
static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
static String keyspaceName = "testCassa";
static String tableName = "employees";
+ static String tableNameConditional = "Conductor";
static String xLatestVersion = "X-latestVersion";
static String onboardUUID = null;
static String lockId = null;
@@ -89,7 +126,7 @@ public class TestRestMusicData {
@BeforeClass
public static void init() throws Exception {
- try {
+ try {
MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
zkServer = new TestingServer(2181, new File("/tmp/zk"));
MusicCore.mLockHandle = new MusicLockingService();
@@ -100,7 +137,6 @@ public class TestRestMusicData {
@AfterClass
public static void tearDownAfterClass() throws Exception {
- System.out.println("After class");
testObject = new PreparedQueryObject();
testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
MusicCore.eventualPut(testObject);
@@ -137,7 +173,7 @@ public class TestRestMusicData {
MusicUtil.DEFAULTKEYSPACENAME));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
- testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), password));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
MusicCore.eventualPut(testObject);
@@ -152,7 +188,7 @@ public class TestRestMusicData {
MusicUtil.DEFAULTKEYSPACENAME));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
- testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), password));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
MusicCore.eventualPut(testObject);
@@ -181,8 +217,26 @@ public class TestRestMusicData {
jsonKeyspace.setKeyspaceName(keyspaceName);
jsonKeyspace.setReplicationInfo(replicationInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Response response = data.createKeySpace("1", "1", "1", null, appName, userId,
- password, jsonKeyspace, keyspaceName);
+ Response response = data.createKeySpace("1", "1", "1", null,authorization, appName, jsonKeyspace, keyspaceName);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200,response.getStatus());
+ }
+
+ @Test
+ public void Test2_createKeyspace1() throws Exception {
+ JsonKeySpace jsonKeyspace = new JsonKeySpace();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> replicationInfo = new HashMap<>();
+ consistencyInfo.put("type", "eventual");
+ replicationInfo.put("class", "SimpleStrategy");
+ replicationInfo.put("replication_factor", 1);
+ jsonKeyspace.setConsistencyInfo(consistencyInfo);
+ jsonKeyspace.setDurabilityOfWrites("true");
+ jsonKeyspace.setKeyspaceName(keyspaceName);
+ jsonKeyspace.setReplicationInfo(replicationInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createKeySpace("1", "1", "1", null,authorization, appName, jsonKeyspace, "keyspaceName");
System.out.println("#######status is " + response.getStatus());
System.out.println("Entity" + response.getEntity());
assertEquals(200,response.getStatus());
@@ -194,8 +248,7 @@ public class TestRestMusicData {
Map<String, String> consistencyInfo = new HashMap<>();
Map<String, Object> replicationInfo = new HashMap<>();
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Response response = data.createKeySpace("1", "1", "1", null, appName, userId,
- password, jsonKeyspace, keyspaceName);
+ Response response = data.createKeySpace("1", "1", "1", null, authorization,appName, jsonKeyspace, keyspaceName);
System.out.println("#######status is " + response.getStatus());
System.out.println("Entity" + response.getEntity());
assertEquals(400,response.getStatus());
@@ -208,8 +261,7 @@ public class TestRestMusicData {
Map<String, Object> replicationInfo = new HashMap<>();
String appName1 = "test";
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Response response = data.createKeySpace("1", "1", "1", null, appName1, userId,
- password, jsonKeyspace, keyspaceName);
+ Response response = data.createKeySpace("1", "1", "1", null,authorization, appName1, jsonKeyspace, keyspaceName);
System.out.println("#######status is " + response.getStatus());
System.out.println("Entity" + response.getEntity());
assertEquals(401,response.getStatus());
@@ -228,14 +280,44 @@ public class TestRestMusicData {
jsonKeyspace.setKeyspaceName("TestApp1");
jsonKeyspace.setReplicationInfo(replicationInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Response response = data.createKeySpace("1", "1", "1", null, "TestApp1",
- "TestUser1", password, jsonKeyspace, keyspaceName);
+ Response response = data.createKeySpace("1", "1", "1", null,authorization, "TestApp1",
+ jsonKeyspace, keyspaceName);
System.out.println("#######status is " + response.getStatus());
System.out.println("Entity" + response.getEntity());
- assertEquals(400,response.getStatus());
+ assertEquals(401,response.getStatus());
}
@Test
+ public void Test2_createKeyspaceEmptyAuth() throws Exception {
+
+ //MockitoAnnotations.initMocks(this);
+ JsonKeySpace jsonKeyspace = new JsonKeySpace();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> replicationInfo = new HashMap<>();
+ consistencyInfo.put("type", "eventual");
+ replicationInfo.put("class", "SimpleStrategy");
+ replicationInfo.put("replication_factor", 1);
+ jsonKeyspace.setConsistencyInfo(consistencyInfo);
+ jsonKeyspace.setDurabilityOfWrites("true");
+ jsonKeyspace.setKeyspaceName(keyspaceName);
+ jsonKeyspace.setReplicationInfo(replicationInfo);
+ //Map<String, Object> m1= new HashMap<>() ;
+ //Mockito.when(CachingUtil.verifyOnboarding("x","y","x")).thenReturn(m1);
+ //Mockito.when(CachingUtil.verifyOnboarding(appNamex,userId,password).thenReturn(m1));
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ String authDatax = ":"+password;
+ String authorizationx = new String(Base64.encode(authDatax.getBytes()));
+ try {
+ Response response = data.createKeySpace("1", "1", "1", null,authorizationx, appName, jsonKeyspace, keyspaceName);
+ //System.out.println("#######status is " + response.getStatus());
+ //System.out.println("Entity" + response.getEntity());
+ //assertNotEquals(200,response.getStatus());
+ } catch (RuntimeException e ) {
+ System.out.println("#######status is runtime exception= " + e);
+ }
+ }
+
+ @Test
public void Test3_createTable() throws Exception {
JsonTable jsonTable = new JsonTable();
Map<String, String> consistencyInfo = new HashMap<>();
@@ -252,12 +334,103 @@ public class TestRestMusicData {
jsonTable.setFields(fields);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.createTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
+ jsonTable, keyspaceName, tableName);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+
+ @Test
+ public void Test3_createTableClusterOrderBad() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name,emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name,emp_salary");
+ jsonTable.setClusteringOrder("ASC");
+ jsonTable.setTableName(tableName);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
jsonTable, keyspaceName, tableName);
System.out.println("#######status is " + response.getStatus());
System.out.println("Entity" + response.getEntity());
+ assertNotEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test3_createTable_withPropertiesNotNull() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name)");
+ consistencyInfo.put("type", "eventual");
+ Map<String, Object> properties = new HashMap<>();
+ properties.put("comment","Testing prperties not null");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ String tableName_prop=tableName+"_Prop";
+ jsonTable.setTableName(tableName_prop);
+ jsonTable.setFields(fields);
+ jsonTable.setProperties(properties);
+
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
+ jsonTable, keyspaceName, tableName_prop);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
assertEquals(200, response.getStatus());
}
+
+ @Test
+ public void Test3_createTable_duplicateTable() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ String tableNameDup=tableName+"X";
+ jsonTable.setTableName(tableNameDup);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameDup);
+ System.out.println("#######status for 1st time " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+
+ Response response0 = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameDup);
+ // 400 is the duplicate status found in response
+ // Music 113 duplicate testing
+ //import static org.junit.Assert.assertNotEquals;
+ System.out.println("#######status for 2nd time " + response0.getStatus());
+ System.out.println("Entity" + response0.getEntity());
+
+ assertFalse("Duplicate table not created for "+tableNameDup, 200==response0.getStatus());
+
+ }
// Improper Auth
@Test
@@ -277,7 +450,7 @@ public class TestRestMusicData {
jsonTable.setFields(fields);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.createTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, "wrong",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
jsonTable, keyspaceName, tableName);
System.out.println("#######status is " + response.getStatus());
System.out.println("Entity" + response.getEntity());
@@ -286,7 +459,7 @@ public class TestRestMusicData {
// Improper keyspace
@Test
- public void Test3_createTable2() throws Exception {
+ public void Test3_createTable3() throws Exception {
JsonTable jsonTable = new JsonTable();
Map<String, String> consistencyInfo = new HashMap<>();
Map<String, String> fields = new HashMap<>();
@@ -302,14 +475,345 @@ public class TestRestMusicData {
jsonTable.setFields(fields);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.createTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
jsonTable, "wrong", tableName);
System.out.println("#######status is " + response.getStatus());
System.out.println("Entity" + response.getEntity());
assertEquals(401, response.getStatus());
}
+
+ @Test
+ public void Test3_createTable3_with_samePartition_clusteringKeys() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name, emp_name)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringKey("emp_name");
+ jsonTable.setTableName(tableName);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableName);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test3_createTable3_with_Partition_clusteringKeys() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringKey("uuid");
+ jsonTable.setTableName(tableName);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, "tableName1");
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ // Improper parenthesis in key field
+ @Test
+ public void Test3_createTable_badParantesis() throws Exception {
+ String tableNameC ="testTable0";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name),emp_id)");
+ fields.put("emp_id", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_id Desc");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ //assertEquals(400, response.getStatus());
+ assertTrue(200 != response.getStatus());
+ }
+
+
+ // good clustering key
+ @Test
+ public void Test3_createTable_1_clusterKey_good() throws Exception {
+ String tableNameC ="testTableC1";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ // jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ // bad partition key=clustering key
+ @Test
+ public void Test3_createTable_2_clusterKey_bad() throws Exception {
+ String tableNameC ="testTableC2";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name),emp_name)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name"); // "PRIMARY KEY" overrides if primaryKey present
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertTrue(200 !=response.getStatus());
+ }
+
+ // good composite partition key,clustering key
+ @Test
+ public void Test3_createTable_3_partition_clusterKey_good() throws Exception {
+ String tableNameC ="testTableC3";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "varint");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name,emp_id),emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ // bad - not all cols in order by of composite partition key,clustering key
+ @Test
+ public void Test3_createTable_4_clusteringOrder_bad() throws Exception {
+ String tableNameC ="testTableC4";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "varint");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name),emp_id,emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertTrue(200 != response.getStatus());
+ }
+
+ // bad - wrong cols in order by of composite partition key,clustering key
+ @Test
+ public void Test3_createTable_5_clusteringOrder_bad() throws Exception {
+ String tableNameC ="testTableC5";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "varint");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_idx desc, emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertTrue(200 != response.getStatus());
+ }
+
+ // bad - wrong cols in order by of composite partition key,clustering key
+ @Test
+ public void Test3_createTable_6_clusteringOrder_bad() throws Exception {
+ String tableNameC ="testTableC6";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "varint");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((uuid,emp_name),emp_id,emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("((uuid,emp_name),emp_id,emp_salary)"); // overridden by
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_id desc, emp_salary ASC,uuid desc");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertTrue(200 != response.getStatus());
+ }
+
+
+ @Test
+ public void Test3_createTableIndex_1() throws Exception {
+ String tableNameC ="testTableCinx";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
+ Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
+ Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
+ response = data.createIndex("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ keyspaceName, tableNameC,"uuid",info);
+ assertEquals(200, response.getStatus());
+ }
+ @Test
+ public void Test3_createTableIndex_badindexname() throws Exception {
+ String tableNameC ="testTableCinx";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
+ Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
+ Mockito.when(rowParams.getFirst("index_name")).thenReturn("my index");
+ response = data.createIndex("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ keyspaceName, tableNameC,"uuid",info);
+ assertEquals(400, response.getStatus());
+ }
+ @Test
+ public void Test3_createTableIndex_wrongindex() throws Exception {
+ String tableNameC ="testTableCinx";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name),emp_salary)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ MultivaluedMap<String, String> rowParams = Mockito.mock(MultivaluedMap.class);
+ Mockito.when(info.getQueryParameters()).thenReturn(rowParams);
+ Mockito.when(rowParams.getFirst("index_name")).thenReturn("my_index");
+ response = data.createIndex("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ keyspaceName, tableNameC,"id",info);
+ assertEquals(400, response.getStatus());
+ }
@Test
public void Test4_insertIntoTable() throws Exception {
@@ -326,7 +830,7 @@ public class TestRestMusicData {
jsonInsert.setValues(values);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
- appName, userId, password, jsonInsert, keyspaceName, tableName);
+ appName, authorization, jsonInsert, keyspaceName, tableName);
assertEquals(200, response.getStatus());
}
@@ -345,7 +849,7 @@ public class TestRestMusicData {
jsonInsert.setValues(values);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.insertIntoTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
jsonInsert, keyspaceName, tableName);
assertEquals(200, response.getStatus());
}
@@ -366,7 +870,7 @@ public class TestRestMusicData {
jsonInsert.setValues(values);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.insertIntoTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, "wrong",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
jsonInsert, keyspaceName, tableName);
assertEquals(401, response.getStatus());
}
@@ -387,14 +891,181 @@ public class TestRestMusicData {
jsonInsert.setValues(values);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.insertIntoTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
jsonInsert, keyspaceName, "wrong");
assertEquals(400, response.getStatus());
}
+ @Test
+ public void Test4_insertIntoTable5() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("id", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test1");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test4_insertIntoTable6() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(400, response.getStatus());
+ }
+ @Test
+ public void Test4_insertIntoTable7() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test2");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ jsonInsert.setTtl("1000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test4_insertIntoTable8() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test3");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ jsonInsert.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
@Test
+ public void Test4_insertIntoTable9() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test4");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ jsonInsert.setTtl("1000");
+ jsonInsert.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test4_insertIntoTable10() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test5");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "critical");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ jsonInsert.setTtl("1000");
+ jsonInsert.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test4_insertIntoTable11() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test6");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ jsonInsert.setTtl("1000");
+ jsonInsert.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test4_insertIntoTable12() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test7");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "atomic");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ jsonInsert.setTtl("1000");
+ jsonInsert.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.insertIntoTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
public void Test5_updateTable() throws Exception {
JsonUpdate jsonUpdate = new JsonUpdate();
Map<String, String> consistencyInfo = new HashMap<>();
@@ -410,7 +1081,292 @@ public class TestRestMusicData {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Mockito.when(info.getQueryParameters()).thenReturn(row);
Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
- userId, password, jsonUpdate, keyspaceName, tableName, info);
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ // need mock code to create error for MusicCore methods
+ @Test
+ public void Test5_updateTableAuthE() throws Exception {
+ MockitoAnnotations.initMocks(this);
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTableAuthException1() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ String authDatax = ":";//+password;
+ String authorizationx = new String(Base64.encode(authDatax.getBytes()));
+ try {
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorizationx, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ } catch(RuntimeException e) {
+ System.out.println("Update table Runtime exception="+e);
+ }
+ }
+
+ @Test
+ public void Test5_updateTableAuthEmpty() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ String authDatax =":"+password;
+ String authorizationx = new String(Base64.encode(authDatax.getBytes()));
+ String appNamex="xx";
+ try {
+ // Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ Response response = data.updateTable("1", "1", "1", "", appNamex,
+ authorizationx, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ } catch(RuntimeException e) {
+ System.out.println("Update table Runtime exception="+e);
+ }
+ }
+
+ @Test
+ public void Test5_updateTable_wrongauth() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ wrongAuthorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(401, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_invalidColumn() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("id", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_ttl() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName8");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ jsonUpdate.setTtl("1000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_timsetamp() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName9");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ jsonUpdate.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_ttl_timestamp() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName10");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ jsonUpdate.setTtl("1000");
+ jsonUpdate.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_rowIdEmpty() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ //row.add("emp_name", "testName3");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ jsonUpdate.setTtl("1000");
+ jsonUpdate.setTimestamp("15000");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_conditions() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ Map<String, Object> conditions = new HashMap<>();
+ conditions.put("emp_name","testName3");
+ row.add("emp_name", "testName3");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ jsonUpdate.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_eventual() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "eventual");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_critical() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "critical");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateTable_atomic_delete_lock() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.updateTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
assertEquals(200, response.getStatus());
}
@@ -424,14 +1380,46 @@ public class TestRestMusicData {
jsonSelect.setConsistencyInfo(consistencyInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Mockito.when(info.getQueryParameters()).thenReturn(row);
- Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
- appName, userId, password, keyspaceName, tableName, info);
+ Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableName, info);
HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
HashMap<String, Object> result = map.get("result");
assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
}
@Test
+ public void Test6_select_withException() throws Exception {
+ JsonSelect jsonSelect = new JsonSelect();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName");
+ consistencyInfo.put("type", "atomic");
+ jsonSelect.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ RestMusicDataAPI spyData = Mockito.spy(RestMusicDataAPI.class);
+ Mockito.doThrow(MusicServiceException.class).when(spyData).selectSpecificQuery("v2", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password, keyspaceName, tableName, info, -1);
+ Response response = spyData.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test6_select_nodata() throws Exception {
+ JsonSelect jsonSelect = new JsonSelect();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName12");
+ consistencyInfo.put("type", "atomic");
+ jsonSelect.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
public void Test6_selectCritical() throws Exception {
JsonInsert jsonInsert = new JsonInsert();
Map<String, String> consistencyInfo = new HashMap<>();
@@ -441,14 +1429,73 @@ public class TestRestMusicData {
jsonInsert.setConsistencyInfo(consistencyInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Mockito.when(info.getQueryParameters()).thenReturn(row);
- Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
- appName, userId, password, jsonInsert, keyspaceName, tableName,info);
+ Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, jsonInsert, keyspaceName, tableName,info);
HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
HashMap<String, Object> result = map.get("result");
assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
}
@Test
+ public void Test6_selectCritical_without_lockID() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName");
+ consistencyInfo.put("type", "critical");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, jsonInsert, keyspaceName, tableName,info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test6_selectCritical_with_atomic_delete_lock() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName");
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, jsonInsert, keyspaceName, tableName,info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test6_selectCritical_with_nodata() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName12");
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.selectCritical("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, jsonInsert, keyspaceName, tableName,info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test6_select_all() throws Exception {
+ JsonSelect jsonSelect = new JsonSelect();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();;
+ consistencyInfo.put("type", "atomic");
+ jsonSelect.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
public void Test6_deleteFromTable() throws Exception {
JsonDelete jsonDelete = new JsonDelete();
Map<String, String> consistencyInfo = new HashMap<>();
@@ -459,7 +1506,7 @@ public class TestRestMusicData {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Mockito.when(info.getQueryParameters()).thenReturn(row);
Response response = data.deleteFromTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
jsonDelete, keyspaceName, tableName, info);
assertEquals(200, response.getStatus());
}
@@ -470,12 +1517,12 @@ public class TestRestMusicData {
JsonDelete jsonDelete = new JsonDelete();
Map<String, String> consistencyInfo = new HashMap<>();
MultivaluedMap<String, String> row = new MultivaluedMapImpl();
- consistencyInfo.put("type", "eventual");
+ consistencyInfo.put("type", "atomic");
jsonDelete.setConsistencyInfo(consistencyInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Mockito.when(info.getQueryParameters()).thenReturn(row);
Response response = data.deleteFromTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
jsonDelete, keyspaceName, tableName, info);
assertEquals(400, response.getStatus());
}
@@ -492,12 +1539,99 @@ public class TestRestMusicData {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Mockito.when(info.getQueryParameters()).thenReturn(row);
Response response = data.deleteFromTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
null, keyspaceName, tableName, info);
assertEquals(400, response.getStatus());
}
@Test
+ public void Test6_deleteFromTable_columns() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test1");
+ consistencyInfo.put("type", "atomic");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ ArrayList<String> columns = new ArrayList<>();
+ columns.add("uuid");
+ jsonDelete.setColumns(columns);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.deleteFromTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonDelete, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test6_deleteFromTable_conditions() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> conditions = new HashMap<>();
+ conditions.put("emp_name","testName3");
+ row.add("emp_name", "test1");
+ consistencyInfo.put("type", "atomic");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ ArrayList<String> columns = new ArrayList<>();
+ jsonDelete.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.deleteFromTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonDelete, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test6_deleteFromTable_eventual() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test2");
+ consistencyInfo.put("type", "eventual");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.deleteFromTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonDelete, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test6_deleteFromTable_critical() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test2");
+ consistencyInfo.put("type", "critical");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.deleteFromTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonDelete, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test6_deleteFromTable_atomic_delete_lock() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test3");
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = data.deleteFromTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonDelete, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
public void Test7_dropTable() throws Exception {
JsonTable jsonTable = new JsonTable();
Map<String, String> consistencyInfo = new HashMap<>();
@@ -505,11 +1639,12 @@ public class TestRestMusicData {
jsonTable.setConsistencyInfo(consistencyInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.dropTable("1", "1", "1",
- "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
keyspaceName, tableName);
assertEquals(200, response.getStatus());
}
+
@Test
public void Test8_deleteKeyspace() throws Exception {
JsonKeySpace jsonKeyspace = new JsonKeySpace();
@@ -524,12 +1659,12 @@ public class TestRestMusicData {
jsonKeyspace.setReplicationInfo(replicationInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
- appName, userId, password, keyspaceName);
+ authorization,appName, keyspaceName);
assertEquals(200, response.getStatus());
}
@Test
- public void Test8_deleteKeyspace2() throws Exception {
+ public void Test8_deleteKeyspace1() throws Exception {
JsonKeySpace jsonKeyspace = new JsonKeySpace();
Map<String, String> consistencyInfo = new HashMap<>();
Map<String, Object> replicationInfo = new HashMap<>();
@@ -542,23 +1677,28 @@ public class TestRestMusicData {
jsonKeyspace.setReplicationInfo(replicationInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
- appName, userId, "wrong", keyspaceName);
- assertEquals(401, response.getStatus());
+ authorization,appName, "keyspaceName");
+ assertEquals(200, response.getStatus());
}
@Test
- public void Test8_deleteKeyspace3() throws Exception {
+ public void Test8_deleteKeyspace2() throws Exception {
JsonKeySpace jsonKeyspace = new JsonKeySpace();
Map<String, String> consistencyInfo = new HashMap<>();
Map<String, Object> replicationInfo = new HashMap<>();
+ consistencyInfo.put("type", "eventual");
+ replicationInfo.put("class", "SimpleStrategy");
+ replicationInfo.put("replication_factor", 1);
+ jsonKeyspace.setConsistencyInfo(consistencyInfo);
+ jsonKeyspace.setDurabilityOfWrites("true");
+ jsonKeyspace.setKeyspaceName("TestApp1");
+ jsonKeyspace.setReplicationInfo(replicationInfo);
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
Response response = data.dropKeySpace("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
- appName, userId, password, keyspaceName);
- assertEquals(400, response.getStatus());
+ wrongAuthorization, appName, keyspaceName);
+ assertEquals(401, response.getStatus());
}
-
-
@Test
public void Test6_onboard() throws Exception {
JsonOnboard jsonOnboard = new JsonOnboard();
@@ -571,6 +1711,18 @@ public class TestRestMusicData {
onboardUUID = resultMap.get("Generated AID").toString();
assertEquals("Your application TestApp2 has been onboarded with MUSIC.", resultMap.get("Success"));
}
+
+ @Test
+ public void Test6_onboard_duplicate() throws Exception {
+ JsonOnboard jsonOnboard = new JsonOnboard();
+ jsonOnboard.setAppname("TestApp2");
+ jsonOnboard.setIsAAF("false");
+ jsonOnboard.setUserId("TestUser2");
+ jsonOnboard.setPassword("TestPassword2");
+ Response response = admin.onboardAppWithMusic(jsonOnboard);
+ assertEquals(400, response.getStatus());
+ }
+
// Missing appname
@Test
public void Test6_onboard1() throws Exception {
@@ -584,7 +1736,7 @@ public class TestRestMusicData {
assertEquals("Unauthorized: Please check the request parameters. Some of the required values appName(ns), userId, password, isAAF are missing.", resultMap.get("Exception"));
}
-
+
@Test
public void Test7_onboardSearch() throws Exception {
JsonOnboard jsonOnboard = new JsonOnboard();
@@ -594,7 +1746,6 @@ public class TestRestMusicData {
Map<String, Object> resultMap = (Map<String, Object>) admin.getOnboardedInfoSearch(jsonOnboard).getEntity();
resultMap.containsKey("success");
assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
-
}
// Missing appname
@@ -607,7 +1758,23 @@ public class TestRestMusicData {
System.out.println("--->" + resultMap.toString());
resultMap.containsKey("success");
assertEquals(MusicUtil.DEFAULTKEYSPACENAME, resultMap.get(onboardUUID));
+ }
+
+ @Test
+ public void Test7_onboardSearch_empty() throws Exception {
+ JsonOnboard jsonOnboard = new JsonOnboard();
+ Response response = admin.getOnboardedInfoSearch(jsonOnboard);
+ assertEquals(400, response.getStatus());
+ }
+ @Test
+ public void Test7_onboardSearch_invalidAid() throws Exception {
+ JsonOnboard jsonOnboard = new JsonOnboard();
+ jsonOnboard.setAppname("TestApp2");
+ jsonOnboard.setIsAAF("false");
+ jsonOnboard.setAid("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
+ Response response = admin.getOnboardedInfoSearch(jsonOnboard);
+ assertEquals(400, response.getStatus());
}
@Test
@@ -680,7 +1847,7 @@ public class TestRestMusicData {
@Test
public void Test3_createLockReference() throws Exception {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1", null, appName, userId, password).getEntity();
+ Map<String, Object> resultMap = (Map<String, Object>) lock.createLockReference(lockName,"1","1",authorization, null, appName).getEntity();
@SuppressWarnings("unchecked")
Map<String, Object> resultMap1 = (Map<String, Object>) resultMap.get("lock");
lockId = (String) resultMap1.get("lock");
@@ -690,28 +1857,388 @@ public class TestRestMusicData {
@Test
public void Test4_accquireLock() throws Exception {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLock(lockId,"1","1", null, appName, userId, password).getEntity();
+ Map<String, Object> resultMap = (Map<String, Object>) lock.accquireLock(lockId,"1","1",authorization, null, appName).getEntity();
assertEquals(ResultType.SUCCESS, resultMap.get("status"));
}
@Test
public void Test5_currentLockHolder() throws Exception {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder(lockName,"1","1", null, appName, userId, password).getEntity();
+ Map<String, Object> resultMap = (Map<String, Object>) lock.currentLockHolder(lockName,"1","1",authorization, null, appName).getEntity();
assertEquals(ResultType.SUCCESS, resultMap.get("status"));
}
@Test
public void Test7_unLock() throws Exception {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Map<String, Object> resultMap = (Map<String, Object>) lock.unLock(lockId,"1","1", null, appName, userId, password).getEntity();
+ Map<String, Object> resultMap = (Map<String, Object>) lock.unLock(lockId,"1","1",authorization, null, appName).getEntity();
assertEquals(ResultType.SUCCESS, resultMap.get("status"));
}
@Test
public void Test8_delete() throws Exception {
Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
- Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null, appName, userId, password).getEntity();
+ Map<String, Object> resultMap = (Map<String, Object>) lock.deleteLock(lockName,"1","1", null,authorization, appName).getEntity();
assertEquals(ResultType.SUCCESS, resultMap.get("status"));
}
+
+ // Version api
+ @Test
+ public void Test1_version( ) {
+ RestMusicVersionAPI versionapi = new RestMusicVersionAPI();
+ HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
+ Map<String, Object> resultMap = versionapi.version(servletResponse);
+ assertEquals(ResultType.SUCCESS, resultMap.get("status"));
+ }
+
+ //Music Test Api
+ @Test
+ public void Test2_testAPI() {
+ RestMusicTestAPI musicTest = new RestMusicTestAPI();
+ HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
+ Map<String, HashMap<String, String>> resultMap = musicTest.simpleTests(servletResponse);
+ assertNotNull(resultMap);
+ }
+
+ //Music Health Check
+ @Test
+ public void Test3_HealthCheck_cassandra() {
+ String consistency = "ONE";
+ RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
+ HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
+ Response response = healthCheck.cassandraStatus(servletResponse, consistency);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test3_HealthCheck_cassandra_cosistencyQuorum() {
+ String consistency = "QUORUM";
+ RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
+ HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
+ Response response = healthCheck.cassandraStatus(servletResponse, consistency);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test3_HealthCheck_zookeeper() {
+ RestMusicHealthCheckAPI healthCheck = new RestMusicHealthCheckAPI();
+ HttpServletResponse servletResponse = Mockito.mock(HttpServletResponse.class);
+ Response response = healthCheck.ZKStatus(servletResponse);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test4_pureZKcreate() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ bmApi.pureZkCreate("sample");
+ }
+
+ @Test
+ public void Test4_pureZKUpdate() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ bmApi.pureZkCreate("sample1");
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "testName_create");
+ values.put("emp_salary", 500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ bmApi.pureZkUpdate(jsonInsert, "sampleNode1");
+ }
+
+ @Test
+ public void Test4_pureZKGet() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ bmApi.pureZkGet("sample");
+ }
+
+ @Test
+ public void Test5_ZKAtomicPut_atomic() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "testName_create");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "atomic");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ bmApi.pureZkAtomicPut(jsonInsert, "lockname", "sampleNode1");
+ }
+
+ @Test
+ public void Test5_ZKAtomicPut_atomic_with_delete() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "testName_create");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ bmApi.pureZkAtomicPut(jsonInsert, "lockname", "sampleNode1");
+ }
+
+ @Test
+ public void Test5_ZKAtomicGet_atomic() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "testName_create");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ bmApi.pureZkAtomicGet(jsonInsert, "lockname", "sampleNode1");
+ }
+
+ @Test
+ public void Test5_ZKAtomicGet_atomic_with_delete() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "testName_create");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "atomic_delete_lock");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ bmApi.pureZkAtomicGet(jsonInsert, "lockname", "sampleNode1");
+ }
+
+ @Test
+ public void Test5_updateCassa() throws Exception {
+ RestMusicBmAPI bmApi = new RestMusicBmAPI();
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName_create");
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ bmApi.updateTableCassa(jsonInsert, keyspaceName, tableName, info);
+ }
+
+ // RestMusicConditional
+ @Test
+ public void Test5_createTable_conditional() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("id", "text");
+ fields.put("plans", "Map<text,text>");
+ fields.put("PRIMARY KEY", "(id)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("id");
+ jsonTable.setTableName(tableNameConditional);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = data.createTable("1", "1", "1",
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",appName, authorization,
+ jsonTable, keyspaceName, tableNameConditional);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test6_insertConditional() throws Exception {
+ RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
+ JsonConditional json = new JsonConditional();
+ json.setPrimaryKey("id");
+ json.setPrimaryKeyValue("123|abc|port");
+ json.setCasscadeColumnName("plans");
+ Map<String, Object> tableValues = new HashMap<>();
+ tableValues.put("id", "123|abc|port");
+ json.setTableValues(tableValues);
+ Map<String, Object> columnData = new HashMap<>();
+ Map<String, String> column = new HashMap<>();
+ column.put("created", "time");
+ columnData.put("key", "P2");
+ columnData.put("value", column);
+ json.setCasscadeColumnData(columnData);
+ Map<String, String> cond = new HashMap<>();
+ Map<String, String> cond1 = new HashMap<>();
+ Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
+ cond.put("status", "under-spin-up");
+ cond1.put("status", "parked");
+ conditions.put("exists", cond);
+ conditions.put("nonexists", cond1);
+ json.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableNameConditional, json);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test6_insertConditional_primaryKey_null() throws Exception {
+ RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
+ JsonConditional json = new JsonConditional();
+ json.setPrimaryKeyValue("123|abc|port");
+ json.setCasscadeColumnName("plans");
+ Map<String, Object> tableValues = new HashMap<>();
+ tableValues.put("id", "123|abc|port");
+ json.setTableValues(tableValues);
+ Map<String, Object> columnData = new HashMap<>();
+ Map<String, String> column = new HashMap<>();
+ column.put("created", "time");
+ columnData.put("key", "P2");
+ columnData.put("value", column);
+ json.setCasscadeColumnData(columnData);
+ Map<String, String> cond = new HashMap<>();
+ Map<String, String> cond1 = new HashMap<>();
+ Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
+ cond.put("status", "under-spin-up");
+ cond1.put("status", "parked");
+ conditions.put("exists", cond);
+ conditions.put("nonexists", cond1);
+ json.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableNameConditional, json);
+ assertEquals(401, response.getStatus());
+ }
+
+ @Test
+ public void Test6_insertConditional_wrongAuth() throws Exception {
+ RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
+ JsonConditional json = new JsonConditional();
+ json.setPrimaryKey("id");
+ json.setPrimaryKeyValue("123|abc|port");
+ json.setCasscadeColumnName("plans");
+ Map<String, Object> tableValues = new HashMap<>();
+ tableValues.put("id", "123|abc|port");
+ json.setTableValues(tableValues);
+ Map<String, Object> columnData = new HashMap<>();
+ Map<String, String> column = new HashMap<>();
+ column.put("created", "time");
+ columnData.put("key", "P2");
+ columnData.put("value", column);
+ json.setCasscadeColumnData(columnData);
+ Map<String, String> cond = new HashMap<>();
+ Map<String, String> cond1 = new HashMap<>();
+ Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
+ cond.put("status", "under-spin-up");
+ cond1.put("status", "parked");
+ conditions.put("exists", cond);
+ conditions.put("nonexists", cond1);
+ json.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = conditionalApi.insertConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
+ assertEquals(401, response.getStatus());
+ }
+
+ @Test
+ public void Test7_updateConditional() throws Exception {
+ RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
+ JsonConditional json = new JsonConditional();
+ json.setPrimaryKey("id");
+ json.setPrimaryKeyValue("123|abc|port");
+ json.setCasscadeColumnName("plans");
+ Map<String, Object> tableValues = new HashMap<>();
+ tableValues.put("id", "123|abc|port");
+ json.setTableValues(tableValues);
+ Map<String, Object> columnData = new HashMap<>();
+ Map<String, String> column = new HashMap<>();
+ column.put("created", "time");
+ columnData.put("key", "P2");
+ columnData.put("value", column);
+ json.setCasscadeColumnData(columnData);
+ Map<String, String> cond = new HashMap<>();
+ Map<String, String> cond1 = new HashMap<>();
+ Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
+ cond.put("updated", "new time");
+ conditions.put("exists", cond);
+ conditions.put("nonexists", cond1);
+ json.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableNameConditional, json);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test7_updateConditional_wrongAuth() throws Exception {
+ RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
+ JsonConditional json = new JsonConditional();
+ json.setPrimaryKey("id");
+ json.setPrimaryKeyValue("123|abc|port");
+ json.setCasscadeColumnName("plans");
+ Map<String, Object> tableValues = new HashMap<>();
+ tableValues.put("id", "123|abc|port");
+ json.setTableValues(tableValues);
+ Map<String, Object> columnData = new HashMap<>();
+ Map<String, String> column = new HashMap<>();
+ column.put("created", "time");
+ columnData.put("key", "P2");
+ columnData.put("value", column);
+ json.setCasscadeColumnData(columnData);
+ Map<String, String> cond = new HashMap<>();
+ Map<String, String> cond1 = new HashMap<>();
+ Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
+ cond.put("updated", "new time");
+ conditions.put("exists", cond);
+ conditions.put("nonexists", cond1);
+ json.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, wrongAuthorization, keyspaceName, tableNameConditional, json);
+ assertEquals(401, response.getStatus());
+ }
+
+ @Test
+ public void Test7_updateConditional_primarykey_null() throws Exception {
+ RestMusicConditionalAPI conditionalApi = new RestMusicConditionalAPI();
+ JsonConditional json = new JsonConditional();
+ json.setPrimaryKeyValue("123|abc|port");
+ json.setCasscadeColumnName("plans");
+ Map<String, Object> tableValues = new HashMap<>();
+ tableValues.put("id", "123|abc|port");
+ json.setTableValues(tableValues);
+ Map<String, Object> columnData = new HashMap<>();
+ Map<String, String> column = new HashMap<>();
+ column.put("created", "time");
+ columnData.put("key", "P2");
+ columnData.put("value", column);
+ json.setCasscadeColumnData(columnData);
+ Map<String, String> cond = new HashMap<>();
+ Map<String, String> cond1 = new HashMap<>();
+ Map<String, Map<String, String>> conditions = new HashMap<String, Map<String, String>>();
+ cond.put("updated", "new time");
+ conditions.put("exists", cond);
+ conditions.put("nonexists", cond1);
+ json.setConditions(conditions);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = conditionalApi.updateConditional("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableNameConditional, json);
+ assertEquals(401, response.getStatus());
+ }
} \ No newline at end of file
diff --git a/src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java b/src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java
new file mode 100644
index 00000000..e75835d1
--- /dev/null
+++ b/src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java
@@ -0,0 +1,1031 @@
+/*
+ * ============LICENSE_START========================================== org.onap.music
+ * =================================================================== Copyright (c) 2017 AT&T
+ * Intellectual Property ===================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License
+ * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+ * or implied. See the License for the specific language governing permissions and limitations under
+ * the License.
+ *
+ * ============LICENSE_END=============================================
+ * ====================================================================
+ */
+package org.onap.music.unittests;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+//cjc import static org.junit.Assert.assertTrue;
+import java.io.File;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.HashMap;
+import java.util.List;
+//cjc import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import javax.servlet.http.HttpServletResponse;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import org.apache.curator.test.TestingServer;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.FixMethodOrder;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.MethodSorters;
+import org.mindrot.jbcrypt.BCrypt;
+//cjcimport org.mindrot.jbcrypt.BCrypt;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.onap.music.datastore.PreparedQueryObject;
+import org.onap.music.datastore.jsonobjects.JsonDelete;
+import org.onap.music.datastore.jsonobjects.JsonInsert;
+import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+//cjc import org.onap.music.datastore.jsonobjects.JsonKeySpace;
+//import org.onap.music.datastore.jsonobjects.JsonOnboard;
+import org.onap.music.datastore.jsonobjects.JsonSelect;
+import org.onap.music.datastore.jsonobjects.JsonTable;
+import org.onap.music.datastore.jsonobjects.JsonUpdate;
+import org.onap.music.lockingservice.MusicLockingService;
+import org.onap.music.main.MusicCore;
+import org.onap.music.main.MusicUtil;
+//import org.onap.music.main.ResultType;
+import org.onap.music.rest.RestMusicAdminAPI;
+import org.onap.music.rest.RestMusicDataAPI;
+import org.onap.music.rest.RestMusicQAPI;
+import org.onap.music.rest.RestMusicLocksAPI;
+import com.datastax.driver.core.DataType;
+import com.datastax.driver.core.ResultSet;
+import com.datastax.driver.core.Row;
+import com.sun.jersey.core.util.Base64;
+//import com.datastax.driver.core.DataType;
+//import com.datastax.driver.core.ResultSet;
+//import com.datastax.driver.core.Row;
+import com.sun.jersey.core.util.MultivaluedMapImpl;
+
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@RunWith(MockitoJUnitRunner.class)
+public class TestRestMusicQAPI {
+
+
+ RestMusicAdminAPI admin = new RestMusicAdminAPI();
+ RestMusicLocksAPI lock = new RestMusicLocksAPI();
+ RestMusicQAPI qData = new RestMusicQAPI();
+ static PreparedQueryObject testObject;
+ static TestingServer zkServer;
+
+ @Mock
+ static HttpServletResponse http;
+
+ @Mock
+ UriInfo info;
+
+ static String appName = "TestApp";
+ static String userId = "TestUser";
+ static String password = "TestPassword";
+ /*
+ static String appName = "com.att.ecomp.portal.demeter.aid";//"TestApp";
+ static String userId = "m00468@portal.ecomp.att.com";//"TestUser";
+ static String password = "happy123";//"TestPassword";
+ */
+ static String authData = userId+":"+password;
+ static String wrongAuthData = userId+":"+"pass";
+ static String authorization = new String(Base64.encode(authData.getBytes()));
+ static String wrongAuthorization = new String(Base64.encode(wrongAuthData.getBytes()));
+
+ static boolean isAAF = false;
+ static UUID uuid = UUID.fromString("abc66ccc-d857-4e90-b1e5-df98a3d40ce6");
+ static String uuidS = "abc66ccc-d857-4e90-b1e5-df98a3d40ce6";
+ static String keyspaceName = "testkscjc";
+ static String tableName = "employees";
+ static String xLatestVersion = "X-latestVersion";
+ static String onboardUUID = null;
+ static String lockId = null;
+ static String lockName = "testkscjc.employees.sample3";
+ static String majorV="3";
+ static String minorV="0";
+ static String patchV="1";
+ static String aid=null;
+ static JsonKeySpace kspObject=null;
+ static RestMusicDataAPI data = new RestMusicDataAPI();
+ static Response resp;
+
+ @BeforeClass
+ public static void init() throws Exception {
+ try {
+ System.out.println("before class cassandra");
+ MusicCore.mDstoreHandle = CassandraCQL.connectToEmbeddedCassandra();
+ System.out.println("before class zoo");
+ zkServer = new TestingServer(2181, new File("/tmp/zk"));
+ MusicCore.mLockHandle = new MusicLockingService();
+ // System.out.println("before class keysp");
+ //resp=data.createKeySpace(majorV,minorV,patchV,aid,appName,userId,password,kspObject,keyspaceName);
+ //System.out.println("after keyspace="+keyspaceName);
+ } catch (Exception e) {
+ System.out.println("before class exception ");
+ e.printStackTrace();
+ }
+ // admin keyspace and table
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString("CREATE KEYSPACE admin WITH REPLICATION = "
+ + "{'class' : 'SimpleStrategy' , "
+ + "'replication_factor': 1} AND DURABLE_WRITES = true");
+ MusicCore.eventualPut(testObject);
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString(
+ "CREATE TABLE admin.keyspace_master (" + " uuid uuid, keyspace_name text,"
+ + " application_name text, is_api boolean,"
+ + " password text, username text,"
+ + " is_aaf boolean, PRIMARY KEY (uuid)\n" + ");");
+ MusicCore.eventualPut(testObject);
+
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString(
+ "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
+ + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(), uuid));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
+ MusicUtil.DEFAULTKEYSPACENAME));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), userId));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
+ MusicCore.eventualPut(testObject);
+
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString(
+ "INSERT INTO admin.keyspace_master (uuid, keyspace_name, application_name, is_api, "
+ + "password, username, is_aaf) VALUES (?,?,?,?,?,?,?)");
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.uuid(),
+ UUID.fromString("bbc66ccc-d857-4e90-b1e5-df98a3d40de6")));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(),
+ MusicUtil.DEFAULTKEYSPACENAME));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestApp1"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), "True"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), BCrypt.hashpw(password, BCrypt.gensalt())));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), "TestUser1"));
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.cboolean(), isAAF));
+ MusicCore.eventualPut(testObject);
+
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString(
+ "select uuid from admin.keyspace_master where application_name = ? allow filtering");
+ testObject.addValue(MusicUtil.convertToActualDataType(DataType.text(), appName));
+ ResultSet rs = MusicCore.get(testObject);
+ List<Row> rows = rs.all();
+ if (rows.size() > 0) {
+ System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid"));
+ }
+
+ JsonKeySpace jsonKeyspace = new JsonKeySpace();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> replicationInfo = new HashMap<>();
+ consistencyInfo.put("type", "eventual");
+ replicationInfo.put("class", "SimpleStrategy");
+ replicationInfo.put("replication_factor", 1);
+ jsonKeyspace.setConsistencyInfo(consistencyInfo);
+ jsonKeyspace.setDurabilityOfWrites("true");
+ jsonKeyspace.setKeyspaceName(keyspaceName);
+ jsonKeyspace.setReplicationInfo(replicationInfo);
+ Response response = data.createKeySpace(majorV, minorV, patchV, null, authorization, appName,
+ jsonKeyspace, keyspaceName);
+ System.out.println("#######status is " + response.getStatus()+" keyspace="+keyspaceName);
+
+ }
+
+ @AfterClass
+ public static void tearDownAfterClass() throws Exception {
+ System.out.println("After class");
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString("DROP KEYSPACE IF EXISTS " + keyspaceName);
+ MusicCore.eventualPut(testObject);
+ testObject = new PreparedQueryObject();
+ testObject.appendQueryString("DROP KEYSPACE IF EXISTS admin");
+ MusicCore.eventualPut(testObject);
+ MusicCore.mDstoreHandle.close();
+ MusicCore.mLockHandle.getzkLockHandle().close();
+ MusicCore.mLockHandle.close();
+ zkServer.stop();
+ }
+
+
+ @Test
+ public void Test1_createQ_good() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setTableName(tableName);
+ jsonTable.setFields(fields);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringKey("uuid");
+ jsonTable.setClusteringOrder("uuid ASC");
+ //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableName);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test1_createQ_FieldsEmpty() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ /*
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name)");
+ */
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableName);
+ jsonTable.setFields(fields);
+ //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableName);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("EmptyFields #######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertNotEquals(200, response.getStatus());
+ }
+ @Test
+ public void Test1_createQ_Clustergood() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringKey("emp_id");
+ jsonTable.setClusteringOrder("emp_id DESC");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test1_createQ_ClusterOrderGood1() throws Exception {
+ String tableNameC="testcjcO";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name,emp_id)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_id DESC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test1_createQ_PartitionKeygood() throws Exception {
+ String tableNameP="testcjcP";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name,emp_salary),emp_id)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setTableName(tableNameP);
+ jsonTable.setClusteringOrder("emp_id DESC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameP);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameP);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test1_createQ_PartitionKeybadclose() throws Exception {
+ String tableNameC="testcjcP1";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name,emp_salary),emp_id))");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name,emp_id");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_id DESC");
+ jsonTable.setFields(fields);
+ //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ //assertEquals(400, response.getStatus());
+ assertTrue(200 != response.getStatus());
+ }
+
+ @Test
+ public void Test1_createQ_ClusterOrderGood2() throws Exception {
+ String tableNameC="testcjcO1g";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name,emp_salary,emp_id)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name,emp_id");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC,emp_id DESC");
+ jsonTable.setFields(fields);
+ //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test1_createQ_ColPkeyoverridesPrimaryKeyGood() throws Exception {
+ String tableNameC="testcjcPr";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "((emp_name),emp_salary,emp_id)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name,emp_id");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_salary ASC,emp_id DESC");
+ jsonTable.setFields(fields);
+ //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(200, response.getStatus());
+ //assertTrue(200 != response.getStatus());
+ }
+
+ @Test
+ public void Test1_createQ_ClusterOrderBad() throws Exception {
+ String tableNameC="testcjcO1b";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name,emp_id)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name,emp_id");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setClusteringOrder("emp_id DESCx");
+ jsonTable.setFields(fields);
+ //System.out.println("cjc before print version, xLatestVersion="+xLatestVersion);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ // "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password,
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+
+ @Test
+ public void Test3_createQ_0() throws Exception {
+ //duplicate testing ...
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ String tableNameDup=tableName+"X";
+ jsonTable.setTableName(tableNameDup);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameDup);
+ System.out.println("#######status for 1st time " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+
+ Response response0 = qData.createQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, keyspaceName, tableNameDup);
+ // 400 is the duplicate status found in response
+ // Music 113 duplicate testing
+ //import static org.junit.Assert.assertNotEquals;
+ System.out.println("#######status for 2nd time " + response0.getStatus());
+ System.out.println("Entity" + response0.getEntity());
+
+ assertFalse("Duplicate table not created for "+tableNameDup, 200==response0.getStatus());
+ //assertEquals(400, response0.getStatus());
+ //assertNotEquals(200,response0.getStatus());
+ }
+
+ // Improper Auth
+ @Test
+ public void Test3_createQ1() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringKey("uuid");
+ jsonTable.setTableName(tableName);
+ jsonTable.setClusteringOrder("uuid DESC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
+ jsonTable, keyspaceName, tableName);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(401, response.getStatus());
+ }
+
+ // Improper keyspace
+ @Test
+ public void Test3_createQ2() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_salary", "varint");
+ fields.put("PRIMARY KEY", "(emp_name)");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setTableName(tableName);
+ jsonTable.setClusteringKey("emp_salary");
+ jsonTable.setClusteringOrder("emp_salary DESC");
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonTable, "wrong", tableName);
+ System.out.println("#######status is " + response.getStatus());
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(401, response.getStatus());
+ }
+
+
+
+ @Test
+ public void Test4_insertIntoQ() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "testName");
+ values.put("emp_salary", 500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.insertIntoQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, jsonInsert, keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
+
+
+ @Test
+ public void Test4_insertIntoQ_valuesEmpty() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ /*
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "testName");
+ values.put("emp_salary", 500);
+ */
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.insertIntoQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, jsonInsert, keyspaceName, tableName);
+ assertNotEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test4_insertIntoQ2() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test1");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.insertIntoQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
+
+ // Auth Error
+ @Test
+ public void Test4_insertIntoQ3() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test1");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.insertIntoQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization,
+ jsonInsert, keyspaceName, tableName);
+ assertEquals(401, response.getStatus());
+ }
+
+ // Table wrong
+ @Test
+ public void Test4_insertIntoQ4() throws Exception {
+ JsonInsert jsonInsert = new JsonInsert();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, Object> values = new HashMap<>();
+ values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_name", "test1");
+ values.put("emp_salary", 1500);
+ consistencyInfo.put("type", "eventual");
+ jsonInsert.setConsistencyInfo(consistencyInfo);
+ jsonInsert.setKeyspaceName(keyspaceName);
+ jsonInsert.setTableName(tableName);
+ jsonInsert.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.insertIntoQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonInsert, keyspaceName, "wrong");
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateQ() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ row.add("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ values.put("emp_salary", "2500");
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = qData.updateQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test5_updateQEmptyValues() throws Exception {
+ JsonUpdate jsonUpdate = new JsonUpdate();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ Map<String, Object> values = new HashMap<>();
+ row.add("emp_name", "testName");
+ //values.put("emp_salary", 2500);
+ consistencyInfo.put("type", "atomic");
+ jsonUpdate.setConsistencyInfo(consistencyInfo);
+ jsonUpdate.setKeyspaceName(keyspaceName);
+ jsonUpdate.setTableName(tableName);
+ jsonUpdate.setValues(values);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = qData.updateQ(majorV, minorV,patchV, "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName,
+ authorization, jsonUpdate, keyspaceName, tableName, info);
+ assertNotEquals(200, response.getStatus());
+ }
+
+ @Test
+ public void Test6_filterQ() throws Exception { //select
+ JsonSelect jsonSelect = new JsonSelect();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName");
+ row.add("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6");
+ consistencyInfo.put("type", "atomic");
+ jsonSelect.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = qData.filter(majorV, minorV,patchV,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableName, info);
+ HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
+ HashMap<String, Object> result = map.get("result");
+ assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
+ }
+
+ @Test
+ public void Test6_peekQ() throws Exception { //select
+ JsonSelect jsonSelect = new JsonSelect();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName");
+ consistencyInfo.put("type", "atomic");
+ jsonSelect.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = qData.peek(majorV, minorV,patchV,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableName, info);
+ HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
+ HashMap<String, Object> result = map.get("result");
+ if (result.isEmpty() ) assertTrue(true);
+ else assertFalse(false);
+ //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
+ }
+
+ @Test
+ public void Test6_peekQ_empty() throws Exception { //select
+ // row is not needed in thhis test
+ JsonSelect jsonSelect = new JsonSelect();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "testName");
+ consistencyInfo.put("type", "atomic");
+ jsonSelect.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ UriInfo infoe= mockUriInfo("/peek?");//empty queryParam: cause exception
+ // infoe.setQueryParameters("");
+ System.out.println("uriinfo="+infoe.getQueryParameters());
+ Mockito.when(infoe.getQueryParameters()).thenReturn(row);
+ Response response = qData.peek(majorV, minorV,patchV,"abc66ccc-d857-4e90-b1e5-df98a3d40ce6",
+ appName, authorization, keyspaceName, tableName, infoe);
+ HashMap<String,HashMap<String,Object>> map = (HashMap<String, HashMap<String, Object>>) response.getEntity();
+ HashMap<String, Object> result = map.get("result");
+ if (result.isEmpty() ) assertTrue(true);
+ else assertFalse(false);
+ //assertEquals("2500", ((HashMap<String,Object>) result.get("row 0")).get("emp_salary").toString());
+ }
+
+ @Test
+ public void Test6_deleteFromQ1() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test1");
+ consistencyInfo.put("type", "atomic");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = qData.deleteFromQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonDelete, keyspaceName, tableName, info);
+ assertEquals(200, response.getStatus());
+ }
+
+ // Values
+ @Test
+ public void Test6_deleteFromQ() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ consistencyInfo.put("type", "atomic");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = qData.deleteFromQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ jsonDelete, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ // delObj
+ @Test
+ public void Test6_deleteFromQ2() throws Exception {
+ JsonDelete jsonDelete = new JsonDelete();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ MultivaluedMap<String, String> row = new MultivaluedMapImpl();
+ row.add("emp_name", "test1");
+ consistencyInfo.put("type", "atomic");
+ jsonDelete.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Mockito.when(info.getQueryParameters()).thenReturn(row);
+ Response response = qData.deleteFromQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ null, keyspaceName, tableName, info);
+ assertEquals(400, response.getStatus());
+ }
+
+ @Test
+ public void Test7_dropQ() throws Exception {
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ consistencyInfo.put("type", "atomic");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.dropQ(majorV, minorV,patchV,
+ "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization,
+ keyspaceName, tableName);
+ assertEquals(200, response.getStatus());
+ }
+
+ private UriInfo mockUriInfo(String urix) throws URISyntaxException {
+ String uri="http://localhost:8080/MUSIC/rest/v"+majorV+"/priorityq/keyspaces/"+keyspaceName+"/"+tableName+urix;
+ UriInfo uriInfo = Mockito.mock(UriInfo.class);
+ System.out.println("mock urix="+urix+" uri="+uri);
+ Mockito.when(uriInfo.getRequestUri()).thenReturn(new URI(uri));
+ return uriInfo;
+ }
+
+
+ //Empty Fields
+ @Test
+ public void Test8_createQ_fields_empty() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringKey("emp_id");
+ jsonTable.setClusteringOrder("emp_id DESC");
+ jsonTable.setTableName(tableNameC);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+ //Partition key null
+ @Test
+ public void Test8_createQ_partitionKey_empty() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setClusteringKey("emp_id");
+ jsonTable.setClusteringOrder("emp_id DESC");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+ //Clustering key null
+ @Test
+ public void Test8_createQ_ClusteringKey_empty() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringOrder("emp_id DESC");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+ //Clustering Order null
+ @Test
+ public void Test8_createQ_ClusteringOrder_empty() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPartitionKey("emp_name");
+ jsonTable.setClusteringKey("emp_id");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+ //Invalid primary key
+ @Test
+ public void Test8_createQ_primaryKey_invalid() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setPrimaryKey("(emp_name");
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setClusteringKey("emp_id");
+ jsonTable.setClusteringOrder("emp_id ASC");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setFields(fields);
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+ //Primary key with no clustering key
+ @Test
+ public void Test8_createQ_primaryKey_with_empty_clusteringKey() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey("emp_name");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setFields(fields);
+ jsonTable.setClusteringOrder("emp_id ASC");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+ //Primary key with no partition key
+ @Test
+ public void Test8_createQ_primaryKey_with_empty_partitionKey() throws Exception {
+ String tableNameC="testcjcC";
+ JsonTable jsonTable = new JsonTable();
+ Map<String, String> consistencyInfo = new HashMap<>();
+ Map<String, String> fields = new HashMap<>();
+ fields.put("uuid", "text");
+ fields.put("emp_name", "text");
+ fields.put("emp_id", "text");
+ fields.put("emp_salary", "varint");
+ consistencyInfo.put("type", "eventual");
+ jsonTable.setConsistencyInfo(consistencyInfo);
+ jsonTable.setKeyspaceName(keyspaceName);
+ jsonTable.setPrimaryKey(" ");
+ jsonTable.setTableName(tableNameC);
+ jsonTable.setFields(fields);
+ jsonTable.setClusteringOrder("emp_id ASC");
+ Mockito.doNothing().when(http).addHeader(xLatestVersion, MusicUtil.getVersion());
+ Response response = qData.createQ(majorV, minorV,patchV,
+ aid, appName, authorization,
+ jsonTable, keyspaceName, tableNameC);
+ System.out.println("#######status is " + response.getStatus()+"table namec="+tableNameC);
+ System.out.println("Entity" + response.getEntity());
+ assertEquals(400, response.getStatus());
+ }
+
+} \ No newline at end of file