package com.rackspacecloud.client.cloudfiles;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.SystemUtils;
import org.apache.log4j.Logger;
import com.rackspacecloud.client.cloudfiles.FilesAccountInfo;
import com.rackspacecloud.client.cloudfiles.FilesCDNContainer;
import com.rackspacecloud.client.cloudfiles.FilesClient;
import com.rackspacecloud.client.cloudfiles.FilesConstants;
import com.rackspacecloud.client.cloudfiles.FilesContainer;
import com.rackspacecloud.client.cloudfiles.FilesContainerExistsException;
import com.rackspacecloud.client.cloudfiles.FilesContainerInfo;
import com.rackspacecloud.client.cloudfiles.FilesInvalidNameException;
import com.rackspacecloud.client.cloudfiles.FilesNotFoundException;
import com.rackspacecloud.client.cloudfiles.FilesObject;
import com.rackspacecloud.client.cloudfiles.FilesObjectMetaData;
import com.rackspacecloud.client.cloudfiles.FilesUtil;
import com.rackspacecloud.client.cloudfiles.IFilesTransferCallback;
import junit.framework.TestCase;
public class SnetFilesClientTestCase extends TestCase {
private static Logger logger = Logger.getLogger(FilesClientTestCase.class);
private static File SYSTEM_TMP = SystemUtils.getJavaIoTmpDir();
private static int NUMBER_RANDOM_BYTES = 513;
public void testConstructor() {
FilesClient client = new FilesClient("foo", "bar", "baz");
assertNotNull(client);
assertEquals("foo", client.getUserName());
assertEquals("bar", client.getPassword());
assertEquals("baz", client.getAccount());
}
public void testNoArgConstructor() {
FilesClient client = new FilesClient();
assertNotNull(client);
assertEquals(FilesUtil.getProperty("username"), client.getUserName());
assertEquals(FilesUtil.getProperty("password"), client.getPassword());
assertEquals(FilesUtil.getProperty("account"), client.getAccount());
}
public void testLogin() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
} catch (Exception e) {
fail(e.getMessage());
}
// Now try a failed login
client = new FilesClient(FilesUtil.getProperty("username"),
FilesUtil.getProperty("password") + " this is a bogus password",
FilesUtil.getProperty("account"));
try {
assertFalse(client.login());
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testAccountInfo() {
String containerName = createTempContainerName("byte-array");
String filename = makeFileName("accountinfo");
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
assertNotNull(client.getContainerInfo(containerName));
// Add some data
byte randomData[] = makeRandomBytes();
assertTrue(client.storeObject(containerName, randomData, "application/octet-stream", filename, new HashMap<String,String>()));
// Do the test if we have an account
if (FilesUtil.getProperty("account") != null) {
FilesAccountInfo info = client.getAccountInfo();
assertTrue(info.getContainerCount() > 0);
assertTrue(info.getBytesUsed() >= randomData.length);
}
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testMultipleFilesNotThere() {
// Tests to make sure we're releasing connections with 404's
FilesClient client = new FilesClient();
String filename = makeFileName("random");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
try {
byte[] content = makeRandomFile(fullPath);
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("file-not-there");
client.createContainer(containerName);
String[] names = new String[10];
for(int i=0; i < 10; ++i) names[i] = "File" + (i + 1) + ".txt";
for(int i=0; i < 5; ++i)
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", names[i]));
for (int i = 0; i < 10; i++) {
String fileName = names[i];
byte[] retrievedContent = null;
try {
retrievedContent = client.getObject(containerName, fileName);
assertArrayEquals(content, retrievedContent);
} catch(FilesNotFoundException ex) {
assertTrue(i >= 5);
}
}
// Cleanup
for(int i=0; i < 5; ++i)
client.deleteObject(containerName, names[i]);
client.deleteContainer(containerName);
} catch (Exception e) {
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testContainerCreation() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
assertNotNull(client.getContainerInfo(containerName));
// Try Adding it again
try {
client.createContainer(containerName);
fail("Allowed duplicate container creation");
}
catch (FilesContainerExistsException fcee) {
// Hooray!
}
// See that it's still there
assertTrue(client.containerExists(containerName));
// Delete it
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testSnetToggle() {
FilesClient client = new FilesClient();
try {
assertTrue(client.login());
client.useSnet();
assertTrue(client.usingSnet());
String containerName = createTempContainerName("");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
client.usePublic();
assertFalse(client.usingSnet());
// See that it's there
assertTrue(client.containerExists(containerName));
assertNotNull(client.getContainerInfo(containerName));
// Try Adding it again
try {
client.createContainer(containerName);
fail("Allowed duplicate container creation");
}
catch (FilesContainerExistsException fcee) {
// Hooray!
}
// See that it's still there
assertTrue(client.containerExists(containerName));
// Delete it
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testContainerNotThereDeletion() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("I'mNotHere!");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
boolean exceptionThrown = false;
try {
client.deleteContainer(containerName);
fail("Exception not thrown");
}
catch (FilesNotFoundException fnfe) {
exceptionThrown = true;
}
assertTrue (exceptionThrown);
// Make still not there
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testContainerCreationWithSpaces() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("with space+and+plus");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
assertNotNull(client.getContainerInfo(containerName));
// Try Adding it again
try {
client.createContainer(containerName);
fail("Allowed duplicate container creation");
}
catch (FilesContainerExistsException fcee) {
// Pass this case
}
// See that it's still there
assertTrue(client.containerExists(containerName));
boolean found = false;
List<FilesContainer> containers = client.listContainers();
for (FilesContainer cont : containers) {
// logger.warn(cont.getName());
if(containerName.equals(cont.getName())) found = true;
}
assertTrue(found);
// Delete it
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testContainerInfoListing() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("<container with\u1422 spaces>");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
assertNotNull(client.getContainerInfo(containerName));
// Try Adding it again
try {
client.createContainer(containerName);
fail("Allowed duplicate container creation");
}
catch (FilesContainerExistsException fcee) {
// Hooray!
}
// See that it's still there
assertTrue(client.containerExists(containerName));
boolean found = false;
List<FilesContainerInfo> containers = client.listContainersInfo();
for (FilesContainerInfo info : containers) {
if(containerName.equals(info.getName())) {
found = true;
assertEquals(0, info.getTotalSize());
assertEquals(0, info.getObjectCount());
}
}
assertTrue(found);
// Delete it
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testUserAgent() {
FilesClient client = new FilesClient();
assertEquals(FilesConstants.USER_AGENT, client.getUserAgent());
client.setUserAgent("Java-Test-User-Agent");
assertEquals("Java-Test-User-Agent", client.getUserAgent());
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("user-agent");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
assertNotNull(client.getContainerInfo(containerName));
// Delete it
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testContainerNameNoSlashes() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("/");
// Make sure they're not there
assertFalse(client.containerExists(containerName));
// Try to add it
boolean exceptionThrown = false;
try {
client.createContainer(containerName);
fail("Should not have been able to create container: " + containerName);
}
catch (FilesInvalidNameException fine) {
exceptionThrown = true;
}
assertTrue(exceptionThrown);
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testFileSaving() {
String containerName = createTempContainerName("file-test");
String filename = makeFileName("random");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
logger.info("Test File Location: " + fullPath);
try {
byte randomData[] = makeRandomFile(fullPath);
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
logger.info("About to save: " + filename);
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", filename));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testSaveAs() {
String containerName = createTempContainerName("file-test");
String filename = makeFileName("random");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
String otherFileName = "Bob";
logger.info("Test File Location: " + fullPath);
try {
byte randomData[] = makeRandomFile(fullPath);
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
logger.info("About to save: " + filename);
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", otherFileName));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals("Bob", obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, otherFileName));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, otherFileName);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, otherFileName);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testFileSavingWithCallback() {
String containerName = createTempContainerName("file-test");
String filename = makeFileName("random");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
logger.info("Test File Location: " + fullPath);
try {
byte randomData[] = makeRandomFile(fullPath);
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
logger.info("About to save: " + filename);
TesterCallback callback = new TesterCallback();
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", filename, callback));
// Make sure the callback was called
assertEquals(randomData.length, callback.bytesSent);
assertEquals(1, callback.nCalls);
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
if (e.getCause() != null) e.getCause().printStackTrace();
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testFileSavingWithMetadata() {
String containerName = createTempContainerName("meta-data-test");
String filename = makeFileName("random-with-meta");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
logger.info("Test File Location: " + fullPath);
try {
byte randomData[] = makeRandomFile(fullPath);
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
HashMap<String,String> meta = new HashMap<String,String>();
meta.put("Foo", "bar");
meta.put("Uni", "\u0169\u00f1\u00efcode-test");
meta.put("Width", "336");
meta.put("Height", "183");
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", filename, meta));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Make sure the metadata is correct
FilesObjectMetaData metadata = client.getObjectMetaData(containerName, filename);
assertNotNull(metadata);
Map<String,String> serverMetadata = metadata.getMetaData();
assertEquals(meta.size(), serverMetadata.size());
for(String key : meta.keySet()) {
assertTrue(serverMetadata.containsKey(key));
assertEquals(meta.get(key), serverMetadata.get(key));
}
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (FilesException e) {
e.printStackTrace();
fail(e.getHttpStatusMessage() + ":" + e.getMessage());
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testFileSavingNoETag() {
String containerName = createTempContainerName("etagless");
String filename = makeFileName("etagless");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
logger.info("Test File Location: " + fullPath);
try {
byte randomData[] = makeRandomFile(fullPath);
FilesClient client = new FilesClient();
assertTrue(client.getUseETag());
client.setUseETag(false);
assertFalse(client.getUseETag());
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", filename));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testContainerListing() {
String containerName = createTempContainerName("<container>");
String filename = makeFileName("<object>");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
logger.info("Test File Location: " + fullPath);
try {
byte randomData[] = makeRandomFile(fullPath);
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
logger.info("About to save: " + filename);
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", filename));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
assertEquals(NUMBER_RANDOM_BYTES, obj.getSize());
assertEquals(md5Sum(randomData), obj.getMd5sum());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testContainerListingWithXML() {
String containerName = createTempContainerName("<container>");
String filename = makeFileName("</name></object>");
try {
byte randomData[] = makeRandomBytes();
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
logger.info("About to save: " + filename);
assertTrue(client.storeObject(containerName, randomData, "application/octet-stream", filename, new HashMap<String,String>()));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
assertEquals(NUMBER_RANDOM_BYTES, obj.getSize());
assertEquals(md5Sum(randomData), obj.getMd5sum());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
fail(e.getMessage());
}
}
public void testByteArraySaving() {
String containerName = createTempContainerName("byte-array");
String filename = makeFileName("bytearray");
try {
byte randomData[] = makeRandomBytes();
FilesClient client = new FilesClient();
// client.setUseETag(false);
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
assertTrue(client.storeObject(containerName, randomData, "application/octet-stream", filename, new HashMap<String,String>()));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testLineNoiseSaving() {
String containerName = createTempContainerName("[]<>{}!@#$%^&*()_-+=|,.?");
String filename = makeFileName("/[]<>{}!@#$%^&*()_-+=|,.?/");
try {
byte randomData[] = makeRandomBytes();
FilesClient client = new FilesClient();
// client.setUseETag(false);
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
assertTrue(client.storeObject(containerName, randomData, "application/octet-stream", filename, new HashMap<String,String>()));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testRequestEntitySaving() {
String containerName = createTempContainerName("requst-entity");
String filename = makeFileName("req-entity");
try {
byte randomData[] = makeRandomBytes();
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
assertTrue(client.storeObject(containerName, randomData, "test/content_type", filename, new HashMap<String,String>()));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("test/content_type", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testObjectListing() {
String containerName = createTempContainerName("object-listing-marker");
try {
byte randomData[] = makeRandomBytes();
FilesClient client = new FilesClient();
// client.setUseETag(false);
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
for (int i=0; i < 10; i++) {
assertTrue(client.storeObject(containerName, randomData, "application/octet-stream", "testfile" + i + ".bogus", new HashMap<String,String>()));
}
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(10, objects.size());
for (int i=0; i < 10; i++) {
FilesObject obj = objects.get(i);
assertEquals("testfile" + i + ".bogus", obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
}
// Now do a limit
objects = client.listObjects(containerName, 3);
assertEquals(3, objects.size());
for (int i=0; i < 3; i++) {
FilesObject obj = objects.get(i);
assertEquals("testfile" + i + ".bogus", obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
}
// Now check out a marker
objects = client.listObjects(containerName, 4, "testfile3.bogus");
assertEquals(4, objects.size());
for (int i=0; i < 4; i++) {
FilesObject obj = objects.get(i);
assertEquals("testfile" + (i + 4) + ".bogus", obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
}
// Clean up
for (int i=0; i < 10; i++) {
client.deleteObject(containerName, "testfile" + i + ".bogus");
}
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testContainerListingWithLimitMarker() {
try {
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Populate our account
for (int i=0; i < 20; i++) {
client.createContainer("test_container_" + i);
}
// Make sure it's there
List<FilesContainer> originalContainers = client.listContainers();
assertTrue(20 <=originalContainers.size());
// Now do a limit
List<FilesContainer> containers = client.listContainers(5);
assertEquals(5, containers.size());
for (int i=0; i < 5; i++) {
FilesContainer container = containers.get(i);
assertEquals(originalContainers.get(i).getName(), container.getName());
}
// Now check out a marker
containers = client.listContainers(10, originalContainers.get(originalContainers.size() - 5).getName());
assertEquals(4, containers.size());
for (int i=0; i < 2; i++) {
FilesContainer container = containers.get(i);
assertEquals(originalContainers.get(originalContainers.size() - 4 + i).getName(), container.getName());
}
// Clean up
for (int i=0; i < 20; i++) {
assertTrue(client.deleteContainer("test_container_" + i));
}
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testByteArraySavingWithCallback() {
String containerName = createTempContainerName("byte-array");
String filename = makeFileName("bytearray");
try {
byte randomData[] = makeRandomBytes(1024 * 100); // 100 K to make sure we do more with the callback
FilesClient client = new FilesClient();
// client.setUseETag(false);
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
TesterCallback callback = new TesterCallback();
assertTrue(client.storeObject(containerName, randomData, "application/octet-stream", filename, new HashMap<String,String>(), callback));
// Make sure it all got written
assertEquals(randomData.length, callback.bytesSent);
assertEquals(randomData.length/8192 + 1, callback.nCalls);
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[randomData.length];
int loc = 0;
int bytesRead = 0;
while ((bytesRead = is.read(otherData, loc, otherData.length - loc)) > 0) {
loc += bytesRead;
}
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testStreamedSaving() {
String containerName = createTempContainerName("streamed");
String filename = makeFileName("streamed");
try {
byte randomData[] = makeRandomBytes(1024 * 100); // 100 K to make sure it's interesting
FilesClient client = new FilesClient();
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
assertNotNull(client.storeStreamedObject(containerName, new ByteArrayInputStream(randomData), "application/octet-stream", filename, new HashMap<String,String>()));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[randomData.length];
int loc = 0;
int bytesRead = 0;
while ((bytesRead = is.read(otherData, loc, otherData.length - loc)) > 0) {
loc += bytesRead;
}
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testMD5IssueSaving() {
String containerName = createTempContainerName("byte-array");
String filename = makeFileName("bytearray");
try {
byte randomData[] = makeRandomBytes();
while(zeroStripMd5Sum(randomData).length() ==32) {
randomData = makeRandomBytes();
}
FilesClient client = new FilesClient();
// client.setUseETag(false);
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
assertTrue(client.storeObject(containerName, randomData, "application/octet-stream", filename, new HashMap<String,String>()));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
private static String zeroStripMd5Sum (byte[] data) throws IOException, NoSuchAlgorithmException
{
MessageDigest digest = MessageDigest.getInstance("MD5");
byte[] md5sum = digest.digest(data);
BigInteger bigInt = new BigInteger(1, md5sum);
return bigInt.toString(16);
}
private static String md5Sum (byte[] data) throws IOException, NoSuchAlgorithmException
{
MessageDigest digest = MessageDigest.getInstance("MD5");
byte[] md5sum = digest.digest(data);
BigInteger bigInt = new BigInteger(1, md5sum);
String result = bigInt.toString(16);
while(result.length() < 32) {
result = "0" + result;
}
return result;
}
public void testUnicodeContainer() {
String containerName = createTempContainerName("\u0169\u00f1\u00efcode-test-\u03de");
try {
FilesClient client = new FilesClient(FilesUtil.getProperty("username"), FilesUtil.getProperty("password"), FilesUtil.getProperty("account"));
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Make sure it's there
assertTrue(client.containerExists(containerName));
// Make sure we can get the container info
assertNotNull(client.getContainerInfo(containerName));
// Clean up
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testUnicode() {
String containerName = createTempContainerName("\u0169\u00f1\u00efcode-test-\u03de");
String filename = makeFileName("unicode_\u03DA_\u2042");
filename = makeFileName("\u00f1\u00efcode-test-\u03de");
String fullPath = FilenameUtils.concat(SYSTEM_TMP.getAbsolutePath(), filename);
logger.info("Test File Location: " + fullPath);
try {
byte randomData[] = makeRandomFile(fullPath);
FilesClient client = new FilesClient(FilesUtil.getProperty("username"), FilesUtil.getProperty("password"), FilesUtil.getProperty("account"));
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
// Set up
client.createContainer(containerName);
// Store it
assertNotNull(client.storeObjectAs(containerName, new File(fullPath), "application/octet-stream", filename));
// Make sure it's there
List<FilesObject> objects = client.listObjects(containerName);
assertEquals(1, objects.size());
FilesObject obj = objects.get(0);
assertEquals(filename, obj.getName());
assertEquals("application/octet-stream", obj.getMimeType());
assertNotNull(obj.getMetaData());
// Make sure the data is correct
assertArrayEquals(randomData, client.getObject(containerName, filename));
// Make sure the data is correct as a stream
InputStream is = client.getObjectAsStream(containerName, filename);
byte otherData[] = new byte[NUMBER_RANDOM_BYTES];
is.read(otherData);
assertArrayEquals(randomData, otherData);
assertEquals(-1, is.read()); // Could hang if there's a bug on the other end
// Make sure we can get the container info
assertNotNull(client.getContainerInfo(containerName));
// Clean up
client.deleteObject(containerName, filename);
assertTrue(client.deleteContainer(containerName));
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
finally {
File f = new File(fullPath);
f.delete();
}
}
public void testCDNContainerList() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
List<String> containers = client.listCdnContainers();
assertTrue(containers.size() > 0);
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testCDNContainerListLimitMarker() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
List<String> originalContainers = client.listCdnContainers();
assertTrue(originalContainers.size() > 0);
// Now do a limit
List<String> containers = client.listCdnContainers(5);
assertEquals(5, containers.size());
for (int i=0; i < 5; i++) {
assertEquals(originalContainers.get(i), containers.get(i));
}
// Now check out a marker
containers = client.listCdnContainers(10, originalContainers.get(originalContainers.size() - 5));
assertEquals(4, containers.size());
for (int i=0; i < 2; i++) {
assertEquals(originalContainers.get(originalContainers.size() - 4 + i), containers.get(i));
}
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testCDNContainerFullListing() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
List<String> originalContainers = client.listCdnContainers();
assertTrue(originalContainers.size() > 0);
// Now do a limit
List<FilesCDNContainer> containers = client.listCdnContainerInfo(5);
assertEquals(5, containers.size());
for (int i=0; i < 5; i++) {
assertEquals(originalContainers.get(i), containers.get(i).getName());
}
// Now check out a marker
containers = client.listCdnContainerInfo(10, originalContainers.get(originalContainers.size() - 5));
assertEquals(4, containers.size());
for (int i=0; i < 2; i++) {
assertEquals(originalContainers.get(originalContainers.size() - 4 + i), containers.get(i).getName());
}
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testCDNContainerFullListingAll() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String container = createTempContainerName("aaa_\u1422_aaa");
client.cdnEnableContainer(container);
// Now do a limit
client.listCdnContainerInfo();
} catch (Exception e) {
fail(e.getMessage());
}
}
public void testCDNApi() {
String containerName = createTempContainerName("java api Test\u03DA_\u2042\u03de#<>\u2043\u2042\u2044\u2045");
//containerName = createTempContainerName("java Api Test no uniocde");
//logger.warn("Container:" + containerName.length() + ":" + containerName);
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
List<String> containers = client.listCdnContainers();
int originalContainerListSize = containers.size();
assertFalse(client.isCDNEnabled(containerName));
String url = client.cdnEnableContainer(containerName);
assertNotNull(url);
assertTrue(client.isCDNEnabled(containerName));
containers = client.listCdnContainers();
assertEquals(originalContainerListSize + 1, containers.size());
boolean found = false;
for(String container : containers) {
// logger.warn(container);
if (containerName.equals(container)) found = true;
}
assertTrue(found);
FilesCDNContainer info = client.getCDNContainerInfo(containerName);
assertTrue(info.isEnabled());
// assertEquals("", info.getUserAgentACL());
// assertEquals("", info.getReferrerACL());
String cdnUrl = info.getCdnURL();
assertNotNull(cdnUrl);
client.cdnUpdateContainer(containerName, 31415, false, true);
assertFalse(client.isCDNEnabled(containerName));
info = client.getCDNContainerInfo(containerName);
assertFalse(info.isEnabled());
assertTrue(info.getRetainLogs());
assertEquals(31415, info.getTtl());
assertEquals(cdnUrl, info.getCdnURL());
//client.cdnUpdateContainer(containerName, 54321, true, "Referrer Test", "User Agent Acl Test");
client.cdnUpdateContainer(containerName, 54321, true, false);
assertTrue(client.isCDNEnabled(containerName));
info = client.getCDNContainerInfo(containerName);
assertTrue(info.isEnabled());
assertFalse(info.getRetainLogs());
assertEquals(54321, info.getTtl());
assertEquals(cdnUrl, info.getCdnURL());
// assertEquals("Referrer Test", info.getReferrerACL());
// assertEquals("User Agent Acl Test", info.getUserAgentACL());
} catch (Exception e) {
fail(e.getMessage());
}
}
// Test container name limits
public void testContainerNameLimits() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
StringBuilder nameBuilder = new StringBuilder(createTempContainerName("long"));
while(nameBuilder.length() <= FilesConstants.CONTAINER_NAME_LENGTH) {
nameBuilder.append("a");
}
try {
client.createContainer(nameBuilder.toString());
// Note, we shouldn't get here, but want to clean up if we do
client.deleteContainer(nameBuilder.toString());
fail("No exception thrown");
}
catch (FilesInvalidNameException fine) {
// Hooray!
}
}
catch (Exception ex) {
fail(ex.getMessage());
}
}
public void testPathCreationAndListing() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("pathTest");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
// Add a path and two files
byte randomData[] = makeRandomBytes();
client.createPath(containerName, "foo");
client.storeObject(containerName, randomData, "application/octet-stream", "notInContainer.dat", new HashMap<String, String>());
client.storeObject(containerName, randomData, "application/octet-stream", "foo/inContainer.dat", new HashMap<String, String>());
List<FilesObject> allObjects = client.listObjects(containerName);
List<FilesObject> pathObjects = client.listObjects(containerName, "foo");
assertEquals(3, allObjects.size());
assertEquals(1, pathObjects.size());
assertEquals("foo/inContainer.dat", pathObjects.get(0).getName());
// Delete it
client.deleteObject(containerName, "notInContainer.dat");
client.deleteObject(containerName, "foo/inContainer.dat");
client.deleteObject(containerName, "foo");
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testPathCreation() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("pathTest");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
// Add a path and two files
client.createFullPath(containerName, "foo/bar/baz");
List<FilesObject> allObjects = client.listObjects(containerName);
assertEquals(3, allObjects.size());
// If we don't throw an exception, we should be OK
client.getObject(containerName, "foo");
client.getObject(containerName, "foo/bar");
client.getObject(containerName, "foo/bar/baz");
// Delete it
client.deleteObject(containerName, "foo/bar/baz");
client.deleteObject(containerName, "foo/bar");
client.deleteObject(containerName, "foo");
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testFilesObjectPath() {
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
String containerName = createTempContainerName("FOpathTest");
// Make sure it's not there
assertFalse(client.containerExists(containerName));
// Add it
client.createContainer(containerName);
// See that it's there
assertTrue(client.containerExists(containerName));
// Add a path and two files
client.createPath(containerName, "test");
List<FilesObject> allObjects = client.listObjects(containerName);
assertEquals(1, allObjects.size());
FilesObject obj = allObjects.get(0);
assertEquals(0, obj.getSize());
assertEquals("application/directory", obj.getMimeType());
// If we don't throw an exception, we should be OK
client.getObject(containerName, "test");
// Delete it
client.deleteObject(containerName, "test");
assertTrue(client.deleteContainer(containerName));
// Make sure it's gone
assertFalse(client.containerExists(containerName));
} catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public void testURLs() {
// Test to make sure these are getting set and are visible to the outside world (needed for Cyberduck's SSL).
FilesClient client = new FilesClient();
try {
client.useSnet();
assertTrue(client.usingSnet());
assertTrue(client.login());
assertNotNull(client.getCdnManagementURL());
assertNotNull(client.getStorageURL());
} catch (Exception e) {
fail(e.getMessage());
}
}
// Fun utilities
private String createTempContainerName(String addition) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss_SSSS");
return "test-container-" + addition + "-" + sdf.format(new Date(System.currentTimeMillis()));
}
private String makeFileName(String addition) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss_SSSS");
return "test-file-" + addition + "-" + sdf.format(new Date(System.currentTimeMillis()));
}
private byte[] makeRandomFile(String name) throws IOException {
File file = new File(name);
FileOutputStream fos = new FileOutputStream(file);
byte randomData[] = makeRandomBytes();
fos.write(randomData);
fos.close();
return randomData;
}
private byte[] makeRandomBytes() {
return makeRandomBytes(NUMBER_RANDOM_BYTES);
}
private byte[] makeRandomBytes(int nBytes) {
byte results[] = new byte[nBytes];
Random gen = new Random();
gen.nextBytes(results);
// Uncomment to get some not so random data
// for(int i=0; i < results.length; ++i) results[i] = (byte) (i % Byte.MAX_VALUE);
return results;
}
private void assertArrayEquals(byte a[], byte b[]) {
assertEquals(a.length, b.length);
for(int i=0; i < a.length; ++i) assertEquals(a[i], b[i]);
}
private class TesterCallback implements IFilesTransferCallback {
public long bytesSent = 0;
public int nCalls = 0;
public void progress(long n) {
bytesSent = n;
++nCalls;
}
}
}