// 2012-08-29 johnpfeiffer TODO: NFS
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
import java.io.IOException;
import java.net.URI;
import org.junit.Before;
import org.junit.Test;
public class StorageGatewayServiceTest
{
private static final String EXPECTEDEFAULTHEADER = "";
private static final String TESTEMCIP = "accesspoint.atmosonline.com";
private static final int TESTEMCPORT = 80;
private static final String TESTEMCUID = "testsubtenant/uid";
private static final String TESTEMCSHAREDSECRET = "testsharedsecret=";
private static final String TESTNIRVANIXAPINAME = "testApiHostName";
private static final String TESTNIRVANIXUSERNAME = "testUsername";
private static final String TESTNIRVANIXPASSWORD = "testPassword";
private static final String TESTNIRVANIXAPPKEY = "testAppKey-testing";
private static final String TESTNIRVANIXAPPNAME = "testAppName";
private static final String TESTCIFSHOST = "testhostname/share";
private static final String TESTCIFSUSER = "DOMAIN/testuser";
private static final String TESTCIFPASSWORD = "p@ssw0rd$%";
private StorageGatewayService testerDefault = null;
private StorageGatewayService tester = null;
@Before
public void setUp() throws Exception
{
testerDefault = new StorageGatewayService.Builder().build();
}
@Test
public void testStorageGatewayService()
{
final String expected = expectedStorageGatewayServiceString( EXPECTEDEFAULTHEADER , StorageGatewayService.DEFAULTOID , StorageGatewayService.DEFAULTHASH ,
StorageGatewayService.DEFAULTDOMAIN , StorageGatewayService.DEFAULTTYPE , AtmosService.DEFAULTATMOSIPADDRESS , AtmosService.DEFAULTATMOSPORT ,
AtmosService.DEFAULTATMOSUID , AtmosService.DEFAULTATMOSSHAREDSECRET , NirvanixService.DEFAULTNIRVANIXAPIHOSTNAME ,
NirvanixService.DEFAULTNIRVANIXUSERNAME , NirvanixService.DEFAULTNIRVANIXPASSWORD , NirvanixService.DEFAULTNIRVANIXAPPKEY ,
NirvanixService.DEFAULTNIRVANIXAPPNAME );
assertEquals( expected , testerDefault.getString( EXPECTEDEFAULTHEADER ) );
}
@Test
public void testStorageGatewayServiceConstructorOid()
{
String testOid = "test-Oid";
tester = new StorageGatewayService.Builder().oid( testOid ).build();
assertEquals( testOid , tester.getOid() );
}
@Test
public void testStorageGatewayServiceOidNull()
{
try
{
new StorageGatewayService.Builder().oid( null ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceOidEmpty()
{
try
{
new StorageGatewayService.Builder().oid( "" ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceOidContainsSpace()
{
try
{
new StorageGatewayService.Builder().oid( "contains awhitespace" ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceOidDoesNotContainDash()
{
try
{
new StorageGatewayService.Builder().oid( "doesnotcontaindash" ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceConstructorHash()
{
String testHash = "test-Hash";
tester = new StorageGatewayService.Builder().hash( testHash ).build();
assertEquals( testHash , tester.getHash() );
}
@Test
public void testStorageGatewayServiceHashNull()
{
try
{
new StorageGatewayService.Builder().hash( null ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceHashEmpty()
{
try
{
new StorageGatewayService.Builder().hash( "" ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceHashDoesNotContainDash()
{
try
{
new StorageGatewayService.Builder().hash( "doesnotcontaindash" ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceConstructorDomain()
{
URI testDomain = URI.create( "testDomain" );
tester = new StorageGatewayService.Builder().domain( testDomain ).build();
assertEquals( testDomain.toString() , tester.getDomain() );
}
@Test
public void testStorageGatewayServiceDomainNull()
{
try
{
new StorageGatewayService.Builder().domain( null ).build();
}catch( IllegalArgumentException iae )
{
return;
}
fail( "Expected IllegalArgumentException" );
}
@Test
public void testStorageGatewayServiceCIFSService() throws IOException
{
CIFSService cifsTemp = new CIFSService.Builder().cifsshare( TESTCIFSHOST ).user( TESTCIFSUSER ).password( TESTCIFPASSWORD ).build();
StorageGatewayService cifsSGW = new StorageGatewayService.Builder().cifs( cifsTemp ).build();
assertEquals( CIFSService.CIFSTORAGETYPE , cifsSGW.getType() );
String expectedCIFSHTML = cifsTemp.getHTMLForm();
assertEquals( expectedCIFSHTML , cifsSGW.getCIFSHTMLForm() );
}
@Test
public void testStorageGatewayServiceAtmos()
{
AtmosService atmosTemp = new AtmosService.Builder().hostname( TESTEMCIP ).port( TESTEMCPORT ).uid( TESTEMCUID ).sharedSecret( TESTEMCSHAREDSECRET ).build();
StorageGatewayService atmosSGWTest = new StorageGatewayService.Builder().atmos( atmosTemp ).build();
assertEquals( AtmosService.ATMOSSTORAGETYPE , atmosSGWTest.getType() );
String expectedAtmosHTML = atmosTemp.getHTMLForm();
assertEquals( expectedAtmosHTML , atmosSGWTest.getAtmosHTMLForm() );
final String expected = expectedStorageGatewayServiceString( EXPECTEDEFAULTHEADER , StorageGatewayService.DEFAULTOID , StorageGatewayService.DEFAULTHASH ,
StorageGatewayService.DEFAULTDOMAIN , AtmosService.ATMOSSTORAGETYPE , TESTEMCIP , TESTEMCPORT , TESTEMCUID , TESTEMCSHAREDSECRET ,
NirvanixService.DEFAULTNIRVANIXAPIHOSTNAME , NirvanixService.DEFAULTNIRVANIXUSERNAME , NirvanixService.DEFAULTNIRVANIXPASSWORD ,
NirvanixService.DEFAULTNIRVANIXAPPKEY , NirvanixService.DEFAULTNIRVANIXAPPNAME );
assertEquals( expected , atmosSGWTest.getString( EXPECTEDEFAULTHEADER ) );
}
@Test
public void testStorageGatewayServiceNirvanix()
{
NirvanixService nirvanixTemp = new NirvanixService.Builder().apihostname( TESTNIRVANIXAPINAME ).user( TESTNIRVANIXUSERNAME )
.password( TESTNIRVANIXPASSWORD ).appkey( TESTNIRVANIXAPPKEY ).appname( TESTNIRVANIXAPPNAME ).build();
StorageGatewayService nirvanixSGW = new StorageGatewayService.Builder().nirvanix( nirvanixTemp ).build();
assertEquals( NirvanixService.NIRVANIXSTORAGETYPE , nirvanixSGW.getType() );
String expectedNirvanixHTML = nirvanixTemp.getHTMLForm();
assertEquals( expectedNirvanixHTML , nirvanixSGW.getNirvanixHTMLForm() );
final String expected = expectedStorageGatewayServiceString( EXPECTEDEFAULTHEADER , StorageGatewayService.DEFAULTOID , StorageGatewayService.DEFAULTHASH ,
StorageGatewayService.DEFAULTDOMAIN , NirvanixService.NIRVANIXSTORAGETYPE , AtmosService.DEFAULTATMOSIPADDRESS , AtmosService.DEFAULTATMOSPORT ,
AtmosService.DEFAULTATMOSUID , AtmosService.DEFAULTATMOSSHAREDSECRET , TESTNIRVANIXAPINAME , TESTNIRVANIXUSERNAME , TESTNIRVANIXPASSWORD ,
TESTNIRVANIXAPPKEY , TESTNIRVANIXAPPNAME );
assertEquals( expected , nirvanixSGW.getString( EXPECTEDEFAULTHEADER ) );
}
// TODO:
@Test
public void testStorageGatewayServiceNFSService() throws IOException
{
}
@Test
public void testGetStorageGatewayOid()
{
assertEquals( StorageGatewayService.DEFAULTOID , testerDefault.getOid() );
}
@Test
public void testGetStorageGatewayHash()
{
assertEquals( StorageGatewayService.DEFAULTHASH , testerDefault.getHash() );
}
@Test
public void testGetStorageGatewayDomain()
{
assertEquals( StorageGatewayService.DEFAULTDOMAIN , testerDefault.getDomain() );
}
@Test
public void testServiceAsString()
{
final String expected = expectedStorageGatewayServiceString( EXPECTEDEFAULTHEADER , StorageGatewayService.DEFAULTOID , StorageGatewayService.DEFAULTHASH ,
StorageGatewayService.DEFAULTDOMAIN , StorageGatewayService.DEFAULTTYPE , AtmosService.DEFAULTATMOSIPADDRESS , AtmosService.DEFAULTATMOSPORT ,
AtmosService.DEFAULTATMOSUID , AtmosService.DEFAULTATMOSSHAREDSECRET , NirvanixService.DEFAULTNIRVANIXAPIHOSTNAME ,
NirvanixService.DEFAULTNIRVANIXUSERNAME , NirvanixService.DEFAULTNIRVANIXPASSWORD , NirvanixService.DEFAULTNIRVANIXAPPKEY ,
NirvanixService.DEFAULTNIRVANIXAPPNAME );
assertEquals( expected , testerDefault.getString( EXPECTEDEFAULTHEADER ) );
}
@Test
public void getAtmosHTMLForm()
{
AtmosService atmos = new AtmosService.Builder().build();
assertEquals( atmos.getHTMLForm() , testerDefault.getAtmosHTMLForm() );
}
@Test
public void getNirvanixHTMLForm()
{
NirvanixService nirvanix = new NirvanixService.Builder().build();
assertEquals( nirvanix.getHTMLForm() , testerDefault.getNirvanixHTMLForm() );
}
@Test
public void getCIFSHTMLForm()
{
CIFSService cifs = new CIFSService.Builder().build();
assertEquals( cifs.getHTMLForm() , testerDefault.getCIFSHTMLForm() );
}
@Test
public void getCIFS()
{
CIFSService cifs = new CIFSService.Builder().cifsshare( "hostget" ).user( "userget" ).password( "passget" ).build();
StorageGatewayService testCIFSGet = new StorageGatewayService.Builder().cifs( cifs ).build();
assertEquals( cifs.getHTMLForm() , testCIFSGet.getCIFSHTMLForm() );
CIFSService returnCIFS = testCIFSGet.getCIFS();
assertEquals( cifs.toString() , returnCIFS.toString() );
}
// TODO: cleanup how download/upload URL's are created
private String expectedStorageGatewayServiceString( String header , String oid , String hash , String accessURL , String type , String emcHostname ,
int emcPort , String emcUID , String emcSecret , String nirvanixApiHostName , String nirvanixUsername , String nirvanixPassword , String nirvanixAppKey ,
String nirvanixAppName )
{
String downloadURL = "https://" + accessURL + "/storagegateway/download";
String uploadURL = "https://" + accessURL + "/storagegateway/upload";
boolean chunkFileSystemIsAvailable = StorageGatewayService.DEFAULTCHUNKFILESYSTEMISAVAILABLE;
String chunkFilesystemStoragePath = StorageGatewayService.DEFAULTCHUNKFILESYSTEMSTORAGEPATH;
if( type.equals( CIFSService.CIFSTORAGETYPE ) )
{
chunkFileSystemIsAvailable = true;
chunkFilesystemStoragePath = CIFSServiceDAO.PARAMCIFSSTORAGEFOLDER;
}else if( type.equals( StorageGatewayService.NFSSTORAGETYPE ) )
{
chunkFileSystemIsAvailable = true;
chunkFilesystemStoragePath = NFSService.PARAMNFSSTORAGEFOLDER;
}
StringBuilder strb = new StringBuilder();
String newline = System.getProperty( "line.separator" );
strb.append( "# version" + StorageGatewayService.CLASSVERSION + newline );
strb.append( header + StorageGatewayService.PARAMSTORAGETYPE + "=" + type + newline );
strb.append( header + StorageGatewayService.PARAMOID + "=" + oid + newline );
strb.append( header + StorageGatewayService.PARAMHASH + "=" + hash + newline );
strb.append( header + StorageGatewayService.PARAMDOWNLOADURL + "=" + downloadURL.toString() + newline );
strb.append( header + StorageGatewayService.PARAMUPLOADURL + "=" + uploadURL.toString() + newline );
strb.append( newline );
strb.append( StorageGatewayService.PARAMSTORAGEGATEWAYTYPES + newline );
strb.append( newline );
strb.append( header + StorageGatewayService.PARAMPERSISTENTSESSIONTRACKERREF + "=" + StorageGatewayService.DEFAULTPERSISTENCEMETHOD + newline );
strb.append( header + StorageGatewayService.PARAMSESSIONFOLDERPATH + "=" + StorageGatewayService.DEFAULTSESSIONFOLDERPATH + newline );
strb.append( header + StorageGatewayService.PARAMTHRIFTSOCKETPORT + "=" + StorageGatewayService.DEFAULTTHRIFTPORT + newline );
strb.append( header + StorageGatewayService.PARAMENCRYPTIONPROVIDERMASTERKEY + "=" + StorageGatewayService.DEFAULTENCRYPTIONMASTERKEY + newline );
strb.append( header + StorageGatewayService.PARAMBLOCKSIZE + "=" + StorageGatewayService.DEFAULTBLOCKSIZE + newline );
strb.append( newline );
strb.append( header + StorageGatewayService.PARAMCHUNKFILESYSTEMISAVAILABLE + "=" + chunkFileSystemIsAvailable + newline );
strb.append( header + StorageGatewayService.PARAMCHUNKFILESYSTEMSTORAGEPATH + "=" + chunkFilesystemStoragePath + newline );
strb.append( newline );
strb.append( header + StorageGatewayService.PARAMFULLFILESYSTEMISAVAILABLE + "=" + StorageGatewayService.DEFAULTFULLFILESYSTEMISAVAILABLE + newline );
strb.append( header + StorageGatewayService.PARAMFULLFILESYSTEMSTORAGEPATH + "=" + StorageGatewayService.DEFAULTFULLFILESYSTEMSTORAGEPATH + newline );
strb.append( header + StorageGatewayService.PARAMROOTFOLDER + "=" + StorageGatewayService.DEFAULTROOTFOLDER + newline );
strb.append( newline );
AtmosService atmos = new AtmosService.Builder().hostname( emcHostname ).port( emcPort ).uid( emcUID ).sharedSecret( emcSecret ).build();
strb.append( atmos.getString( header ) );
strb.append( newline );
NirvanixService nirvanix = new NirvanixService.Builder().apihostname( nirvanixApiHostName ).user( nirvanixUsername ).password( nirvanixPassword )
.appkey( nirvanixAppKey ).appname( nirvanixAppName ).build();
strb.append( nirvanix.getString( header ) );
strb.append( newline );
S3Service s3 = new S3Service();
strb.append( s3.getString( header ) );
strb.append( newline );
strb.append( header + StorageGatewayService.PARAMJDBCMAXRESULTS + "=" + StorageGatewayService.DEFAULTJDBCMAXRESULTS + newline );
strb.append( header + StorageGatewayService.PARAMJDBCMAXPOOLSIZE + "=" + StorageGatewayService.DEFAULTJDBCMAXPOOLSIZE + newline );
strb.append( header + StorageGatewayService.PARAMRDBMSMAXLISTRESULT + "=" + StorageGatewayService.DEFAULTRDBMSMAXLISTRESULT + newline );
strb.append( header + StorageGatewayService.PARAMJDBCDATABASEDRIVER + "=" + StorageGatewayService.DEFAULTJDBCDATABASEDRIVER + newline );
strb.append( header + StorageGatewayService.PARAMJDBCDATABASEURL + "=" + StorageGatewayService.DEFAULTJDBCDATABASEURL + newline );
strb.append( header + StorageGatewayService.PARAMJDBCDATABASEUSERNAME + "=" + StorageGatewayService.DEFAULTJDBCDATABASEUSERNAME + newline );
strb.append( header + StorageGatewayService.PARAMJDBCDATABASEPASSWORD + "=" + StorageGatewayService.DEFAULTJDBCDATABASEPASSWORD + newline );
strb.append( header + StorageGatewayService.PARAMJDBCDATABASEDIALECT + "=" + StorageGatewayService.DEFAULTJDBCDATABASEDIALECT + newline );
strb.append( newline );
strb.append( header + StorageGatewayService.PARAMUSECOMMONCACHELOCK + "=" + StorageGatewayService.DEFAULTUSECOMMONCACHELOCK + newline );
strb.append( header + StorageGatewayService.PARAMCACHEPOOL + "=" + StorageGatewayService.DEFAULTCACHEPOOL + newline );
strb.append( header + StorageGatewayService.PARAMCACHEFACTORY + "=" + StorageGatewayService.DEFAULTCACHEFACTORY + newline );
strb.append( header + StorageGatewayService.PARAMCACHEHOSTS + "=" + StorageGatewayService.DEFAULTCACHEHOSTS + newline );
strb.append( header + StorageGatewayService.PARAMCACHEEXPIRATIONMINUTES + "=" + StorageGatewayService.DEFAULTCACHEEXPIRATIONMINUTES + newline );
strb.append( header + StorageGatewayService.PARAMCACHEMAXIDLE + "=" + StorageGatewayService.DEFAULTCACHEMAXIDLE + newline );
strb.append( header + StorageGatewayService.PARAMCACHEMAXACTIVE + "=" + StorageGatewayService.DEFAULTCACHEMAXACTIVE + newline );
strb.append( header + StorageGatewayService.PARAMCACHEMAXWAITINMILLISEC + "=" + StorageGatewayService.DEFAULTCACHEMAXWAITINMILLISEC + newline );
return strb.toString();
}
} // end class