From 9b6efbd93a12c858a0d2643013217ec3d6c3a46d Mon Sep 17 00:00:00 2001 From: "Thomas Nelson Jr (arthurdent3) tn1381@att.com" Date: Mon, 16 Jul 2018 16:41:20 -0400 Subject: 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 --- .../org/onap/music/unittests/TestMusicCore.java | 197 ++- .../onap/music/unittests/TestRestMusicData.java | 1807 ++++++++++++++++++-- .../onap/music/unittests/TestRestMusicQAPI.java | 1031 +++++++++++ 3 files changed, 2891 insertions(+), 144 deletions(-) create mode 100644 src/test/java/org/onap/music/unittests/TestRestMusicQAPI.java (limited to 'src/test/java/org/onap/music') 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 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> 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); Map 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 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,13 +280,43 @@ 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 consistencyInfo = new HashMap<>(); + Map 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 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(); @@ -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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); Map fields = new HashMap<>(); @@ -302,152 +475,1026 @@ 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 Test4_insertIntoTable() throws Exception { - JsonInsert jsonInsert = new JsonInsert(); + public void Test3_createTable3_with_samePartition_clusteringKeys() throws Exception { + JsonTable jsonTable = new JsonTable(); Map consistencyInfo = new HashMap<>(); - Map values = new HashMap<>(); - values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); - values.put("emp_name", "testName"); - values.put("emp_salary", 500); + Map 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"); - jsonInsert.setConsistencyInfo(consistencyInfo); - jsonInsert.setKeyspaceName(keyspaceName); - jsonInsert.setTableName(tableName); - jsonInsert.setValues(values); + 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.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", - appName, userId, password, jsonInsert, keyspaceName, tableName); - assertEquals(200, response.getStatus()); + 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 Test4_insertIntoTable2() throws Exception { - JsonInsert jsonInsert = new JsonInsert(); + public void Test3_createTable3_with_Partition_clusteringKeys() throws Exception { + JsonTable jsonTable = new JsonTable(); Map consistencyInfo = new HashMap<>(); - Map values = new HashMap<>(); - values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); - values.put("emp_name", "test1"); - values.put("emp_salary", 1500); + Map fields = new HashMap<>(); + fields.put("uuid", "text"); + fields.put("emp_name", "text"); + fields.put("emp_salary", "varint"); consistencyInfo.put("type", "eventual"); - jsonInsert.setConsistencyInfo(consistencyInfo); - jsonInsert.setKeyspaceName(keyspaceName); - jsonInsert.setTableName(tableName); - jsonInsert.setValues(values); + 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.insertIntoTable("1", "1", "1", - "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, password, - jsonInsert, keyspaceName, tableName); + 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()); } - // Auth Error + // Improper parenthesis in key field @Test - public void Test4_insertIntoTable3() throws Exception { - JsonInsert jsonInsert = new JsonInsert(); + public void Test3_createTable_badParantesis() throws Exception { + String tableNameC ="testTable0"; + JsonTable jsonTable = new JsonTable(); Map consistencyInfo = new HashMap<>(); - Map values = new HashMap<>(); - values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); - values.put("emp_name", "test1"); - values.put("emp_salary", 1500); + Map 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"); - jsonInsert.setConsistencyInfo(consistencyInfo); - jsonInsert.setKeyspaceName(keyspaceName); - jsonInsert.setTableName(tableName); - jsonInsert.setValues(values); + 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.insertIntoTable("1", "1", "1", - "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, userId, "wrong", - jsonInsert, keyspaceName, tableName); - assertEquals(401, response.getStatus()); + 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()); } + - // Table wrong + // good clustering key @Test - public void Test4_insertIntoTable4() throws Exception { - JsonInsert jsonInsert = new JsonInsert(); + public void Test3_createTable_1_clusterKey_good() throws Exception { + String tableNameC ="testTableC1"; + JsonTable jsonTable = new JsonTable(); Map consistencyInfo = new HashMap<>(); - Map values = new HashMap<>(); - values.put("uuid", "cfd66ccc-d857-4e90-b1e5-df98a3d40cd6"); - values.put("emp_name", "test1"); - values.put("emp_salary", 1500); + Map 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"); - 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, userId, password, - jsonInsert, keyspaceName, "wrong"); - assertEquals(400, response.getStatus()); - } - - - - @Test - public void Test5_updateTable() throws Exception { - JsonUpdate jsonUpdate = new JsonUpdate(); - Map consistencyInfo = new HashMap<>(); - MultivaluedMap row = new MultivaluedMapImpl(); - Map 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); + 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()); - 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); + 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 Test6_select() throws Exception { - JsonSelect jsonSelect = new JsonSelect(); + public void Test3_createTable_2_clusterKey_bad() throws Exception { + String tableNameC ="testTableC2"; + JsonTable jsonTable = new JsonTable(); Map consistencyInfo = new HashMap<>(); - MultivaluedMap row = new MultivaluedMapImpl(); - row.add("emp_name", "testName"); - consistencyInfo.put("type", "atomic"); - jsonSelect.setConsistencyInfo(consistencyInfo); + Map 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()); - Mockito.when(info.getQueryParameters()).thenReturn(row); - Response response = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6", - appName, userId, password, keyspaceName, tableName, info); - HashMap> map = (HashMap>) response.getEntity(); - HashMap result = map.get("result"); - assertEquals("2500", ((HashMap) result.get("row 0")).get("emp_salary").toString()); + 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 Test6_selectCritical() throws Exception { - JsonInsert jsonInsert = new JsonInsert(); + public void Test3_createTable_3_partition_clusterKey_good() throws Exception { + String tableNameC ="testTableC3"; + JsonTable jsonTable = new JsonTable(); Map consistencyInfo = new HashMap<>(); - MultivaluedMap row = new MultivaluedMapImpl(); - row.add("emp_name", "testName"); - consistencyInfo.put("type", "atomic"); - 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); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 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 consistencyInfo = new HashMap<>(); + Map 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 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 consistencyInfo = new HashMap<>(); + Map 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 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 { + JsonInsert jsonInsert = new JsonInsert(); + Map consistencyInfo = new HashMap<>(); + Map 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 = data.insertIntoTable("1", "1", "1", "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", + appName, authorization, jsonInsert, keyspaceName, tableName); + assertEquals(200, response.getStatus()); + } + + @Test + public void Test4_insertIntoTable2() throws Exception { + JsonInsert jsonInsert = new JsonInsert(); + Map consistencyInfo = new HashMap<>(); + Map 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 = data.insertIntoTable("1", "1", "1", + "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, authorization, + jsonInsert, keyspaceName, tableName); + assertEquals(200, response.getStatus()); + } + + // Auth Error + @Test + public void Test4_insertIntoTable3() throws Exception { + JsonInsert jsonInsert = new JsonInsert(); + Map consistencyInfo = new HashMap<>(); + Map 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 = data.insertIntoTable("1", "1", "1", + "abc66ccc-d857-4e90-b1e5-df98a3d40ce6", appName, wrongAuthorization, + jsonInsert, keyspaceName, tableName); + assertEquals(401, response.getStatus()); + } + + // Table wrong + @Test + public void Test4_insertIntoTable4() throws Exception { + JsonInsert jsonInsert = new JsonInsert(); + Map consistencyInfo = new HashMap<>(); + Map 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 = data.insertIntoTable("1", "1", "1", + "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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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()); + } + + // need mock code to create error for MusicCore methods + @Test + public void Test5_updateTableAuthE() throws Exception { + MockitoAnnotations.initMocks(this); + JsonUpdate jsonUpdate = new JsonUpdate(); + Map consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map values = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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()); + } + + @Test + public void Test6_select() throws Exception { + JsonSelect jsonSelect = new JsonSelect(); + Map consistencyInfo = new HashMap<>(); + MultivaluedMap 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 = data.select("1", "1", "1","abc66ccc-d857-4e90-b1e5-df98a3d40ce6", + appName, authorization, keyspaceName, tableName, info); + HashMap> map = (HashMap>) response.getEntity(); + HashMap result = map.get("result"); + assertEquals("2500", ((HashMap) result.get("row 0")).get("emp_salary").toString()); + } + + @Test + public void Test6_select_withException() throws Exception { + JsonSelect jsonSelect = new JsonSelect(); + Map consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + row.add("emp_name", "testName"); + consistencyInfo.put("type", "atomic"); + 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); HashMap> map = (HashMap>) response.getEntity(); HashMap result = map.get("result"); assertEquals("2500", ((HashMap) result.get("row 0")).get("emp_salary").toString()); } + @Test + public void Test6_selectCritical_without_lockID() throws Exception { + JsonInsert jsonInsert = new JsonInsert(); + Map consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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(); @@ -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 consistencyInfo = new HashMap<>(); MultivaluedMap 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,11 +1539,98 @@ 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + row.add("emp_name", "test1"); + consistencyInfo.put("type", "atomic"); + jsonDelete.setConsistencyInfo(consistencyInfo); + ArrayList 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map conditions = new HashMap<>(); + conditions.put("emp_name","testName3"); + row.add("emp_name", "test1"); + consistencyInfo.put("type", "atomic"); + jsonDelete.setConsistencyInfo(consistencyInfo); + ArrayList 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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(); @@ -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 consistencyInfo = new HashMap<>(); Map 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 consistencyInfo = new HashMap<>(); Map 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 resultMap = (Map) 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 resultMap = (Map) lock.createLockReference(lockName,"1","1", null, appName, userId, password).getEntity(); + Map resultMap = (Map) lock.createLockReference(lockName,"1","1",authorization, null, appName).getEntity(); @SuppressWarnings("unchecked") Map resultMap1 = (Map) 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 resultMap = (Map) lock.accquireLock(lockId,"1","1", null, appName, userId, password).getEntity(); + Map resultMap = (Map) 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 resultMap = (Map) lock.currentLockHolder(lockName,"1","1", null, appName, userId, password).getEntity(); + Map resultMap = (Map) 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 resultMap = (Map) lock.unLock(lockId,"1","1", null, appName, userId, password).getEntity(); + Map resultMap = (Map) 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 resultMap = (Map) lock.deleteLock(lockName,"1","1", null, appName, userId, password).getEntity(); + Map resultMap = (Map) 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 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> 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 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 consistencyInfo = new HashMap<>(); + Map fields = new HashMap<>(); + fields.put("id", "text"); + fields.put("plans", "Map"); + 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 tableValues = new HashMap<>(); + tableValues.put("id", "123|abc|port"); + json.setTableValues(tableValues); + Map columnData = new HashMap<>(); + Map column = new HashMap<>(); + column.put("created", "time"); + columnData.put("key", "P2"); + columnData.put("value", column); + json.setCasscadeColumnData(columnData); + Map cond = new HashMap<>(); + Map cond1 = new HashMap<>(); + Map> conditions = new HashMap>(); + 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 tableValues = new HashMap<>(); + tableValues.put("id", "123|abc|port"); + json.setTableValues(tableValues); + Map columnData = new HashMap<>(); + Map column = new HashMap<>(); + column.put("created", "time"); + columnData.put("key", "P2"); + columnData.put("value", column); + json.setCasscadeColumnData(columnData); + Map cond = new HashMap<>(); + Map cond1 = new HashMap<>(); + Map> conditions = new HashMap>(); + 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 tableValues = new HashMap<>(); + tableValues.put("id", "123|abc|port"); + json.setTableValues(tableValues); + Map columnData = new HashMap<>(); + Map column = new HashMap<>(); + column.put("created", "time"); + columnData.put("key", "P2"); + columnData.put("value", column); + json.setCasscadeColumnData(columnData); + Map cond = new HashMap<>(); + Map cond1 = new HashMap<>(); + Map> conditions = new HashMap>(); + 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 tableValues = new HashMap<>(); + tableValues.put("id", "123|abc|port"); + json.setTableValues(tableValues); + Map columnData = new HashMap<>(); + Map column = new HashMap<>(); + column.put("created", "time"); + columnData.put("key", "P2"); + columnData.put("value", column); + json.setCasscadeColumnData(columnData); + Map cond = new HashMap<>(); + Map cond1 = new HashMap<>(); + Map> conditions = new HashMap>(); + 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 tableValues = new HashMap<>(); + tableValues.put("id", "123|abc|port"); + json.setTableValues(tableValues); + Map columnData = new HashMap<>(); + Map column = new HashMap<>(); + column.put("created", "time"); + columnData.put("key", "P2"); + columnData.put("value", column); + json.setCasscadeColumnData(columnData); + Map cond = new HashMap<>(); + Map cond1 = new HashMap<>(); + Map> conditions = new HashMap>(); + 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 tableValues = new HashMap<>(); + tableValues.put("id", "123|abc|port"); + json.setTableValues(tableValues); + Map columnData = new HashMap<>(); + Map column = new HashMap<>(); + column.put("created", "time"); + columnData.put("key", "P2"); + columnData.put("value", column); + json.setCasscadeColumnData(columnData); + Map cond = new HashMap<>(); + Map cond1 = new HashMap<>(); + Map> conditions = new HashMap>(); + 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 rows = rs.all(); + if (rows.size() > 0) { + System.out.println("#######UUID is:" + rows.get(0).getUUID("uuid")); + } + + JsonKeySpace jsonKeyspace = new JsonKeySpace(); + Map consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap row = new MultivaluedMapImpl(); + Map 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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> map = (HashMap>) response.getEntity(); + HashMap result = map.get("result"); + assertEquals("2500", ((HashMap) result.get("row 0")).get("emp_salary").toString()); + } + + @Test + public void Test6_peekQ() throws Exception { //select + JsonSelect jsonSelect = new JsonSelect(); + Map consistencyInfo = new HashMap<>(); + MultivaluedMap 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> map = (HashMap>) response.getEntity(); + HashMap result = map.get("result"); + if (result.isEmpty() ) assertTrue(true); + else assertFalse(false); + //assertEquals("2500", ((HashMap) 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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> map = (HashMap>) response.getEntity(); + HashMap result = map.get("result"); + if (result.isEmpty() ) assertTrue(true); + else assertFalse(false); + //assertEquals("2500", ((HashMap) result.get("row 0")).get("emp_salary").toString()); + } + + @Test + public void Test6_deleteFromQ1() throws Exception { + JsonDelete jsonDelete = new JsonDelete(); + Map consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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 consistencyInfo = new HashMap<>(); + MultivaluedMap 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 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 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 consistencyInfo = new HashMap<>(); + Map 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 -- cgit 1.2.3-korg