/** Test of isAbsolute method, of class PathUtils. */
public void testIsAbsolute() {
System.out.println("isAbsolute");
assertTrue(PathUtils.isAbsolute("/absolute"));
assertTrue(PathUtils.isAbsolute("/any/absolute/paths"));
assertFalse(PathUtils.isAbsolute("relative path"));
assertFalse(PathUtils.isAbsolute("../../data"));
assertFalse(PathUtils.isAbsolute("http://www.seznam.cz"));
}
/** Test of processResource method, of class PathUtils. */
public void testProcessResource() {
System.out.println("processResource");
// Tests of absolute and remotes
assertEquals(
"http://www.seznam.cz", PathUtils.processResource("http://www.seznam.cz", Paths.get("")));
assertEquals(
"https://a.b/q/w/e",
PathUtils.processResource("https://a.b/q/w/e", Paths.get("some/context/file.lesscache")));
assertEquals("/file", PathUtils.processResource("/file", Paths.get("")));
assertEquals(
"/abs/path/file",
PathUtils.processResource("/abs/path/file", Paths.get("some/context/file.lesscache")));
// Tests relative
assertEquals(
Paths.get("some/context/file.txt").toString(),
PathUtils.processResource("file.txt", Paths.get("some/context")));
assertEquals(
Paths.get("some/context/file.txt").toString(),
PathUtils.processResource("file.txt", Paths.get("some/context/")));
assertEquals(
Paths.get("some/file.txt").toString(),
PathUtils.processResource("../file.txt", Paths.get("some/context")));
assertEquals(
Paths.get("../../file.txt").toString(),
PathUtils.processResource("../file.txt", Paths.get("../")));
assertEquals(
Paths.get("../file.txt").toString(),
PathUtils.processResource("file.txt", Paths.get("../")));
}
@SuppressWarnings({"OverlyComplexMethod"})
private static String removeDotSegments(String path) {
if (null == path) {
return null;
}
List<String> outputSegments = new LinkedList<>();
while (path.length() > 0) {
if (path.startsWith("../")) { // rule 2A
path = PathUtils.trimLeadingSlashes(path.substring(3));
} else if (path.startsWith("./")) { // rule 2A
path = PathUtils.trimLeadingSlashes(path.substring(2));
} else if (path.startsWith("/./")) { // rule 2B
path = "/" + PathUtils.trimLeadingSlashes(path.substring(3));
} else if ("/.".equals(path)) { // rule 2B
path = "/";
} else if (path.startsWith("/../")) { // rule 2C
path = "/" + PathUtils.trimLeadingSlashes(path.substring(4));
if (!outputSegments.isEmpty()) { // removing last segment if any
outputSegments.remove(outputSegments.size() - 1);
}
} else if ("/..".equals(path)) { // rule 2C
path = "/";
if (!outputSegments.isEmpty()) { // removing last segment if any
outputSegments.remove(outputSegments.size() - 1);
}
} else if ("..".equals(path) || ".".equals(path)) { // rule 2D
path = "";
} else { // rule E
int slashStartSearchIndex;
if (path.startsWith("/")) {
path = "/" + PathUtils.trimLeadingSlashes(path.substring(1));
slashStartSearchIndex = 1;
} else {
slashStartSearchIndex = 0;
}
int segLength = path.indexOf('/', slashStartSearchIndex);
if (-1 == segLength) {
segLength = path.length();
}
outputSegments.add(path.substring(0, segLength));
path = path.substring(segLength);
}
}
StringBuffer result = new StringBuffer();
for (String segment : outputSegments) {
result.append(segment);
}
return result.toString();
}
@Test
public void notExistingBackupDir() throws Exception {
Path dirToBkp = Files.createTempDirectory("dirToBkp2");
Path parentdirfile1 = createTempFile(dirToBkp, "FILE_1", ".tmp");
Path parentdirfile2 = createTempFile(dirToBkp, "FILE_2", ".tmp");
new BackupHelper(conf).backupFileOrDir(dirToBkp);
Path bkp = PathUtils.get(conf.getBackupDir(), dirToBkp);
assertThat(exists(bkp), is(true));
assertThat(exists(PathUtils.get(bkp, parentdirfile1.getFileName())), is(true));
assertThat(exists(PathUtils.get(bkp, parentdirfile2.getFileName())), is(true));
}
public static void writeNodeContentsToWriter(JSONWriter write, Node node)
throws RepositoryException, JSONException {
// Since removal of bigstore we add in jcr:path and jcr:name
write.key("jcr:path");
write.value(PathUtils.translateAuthorizablePath(node.getPath()));
write.key("jcr:name");
write.value(node.getName());
PropertyIterator properties = node.getProperties();
while (properties.hasNext()) {
Property prop = properties.nextProperty();
String name = prop.getName();
write.key(name);
PropertyDefinition propertyDefinition = prop.getDefinition();
int propertyType = prop.getType();
if (PropertyType.BINARY == propertyType) {
if (propertyDefinition.isMultiple()) {
write.array();
for (long l : prop.getLengths()) {
write.value("binary-length:" + String.valueOf(l));
}
write.endArray();
} else {
write.value("binary-length:" + String.valueOf(prop.getLength()));
}
} else {
if (propertyDefinition.isMultiple()) {
Value[] values = prop.getValues();
write.array();
for (Value value : values) {
Object ovalue = stringValue(value);
if (isUserPath(name, ovalue)) {
write.value(PathUtils.translateAuthorizablePath(ovalue));
} else {
write.value(ovalue);
}
}
write.endArray();
} else {
Object value = stringValue(prop.getValue());
if (isUserPath(name, value)) {
write.value(PathUtils.translateAuthorizablePath(value));
} else {
write.value(value);
}
}
}
}
}
@Test
public void bookFilePathWithSeriesInItWillReturnBookWithSeriesInItsName() throws Exception {
String author = "Лукьяненко Сергей";
String bookName = "Лукьяненко 3 Калеки";
String seriesName = "Геном";
final String fileName = bookName + ".fb2.zip";
final String path = PathUtils.createPath("ru", "Л", author, seriesName, fileName);
mockery.checking(
new Expectations() {
{
allowing(fs).exists(path);
will(returnValue(true));
allowing(fs).isDirectory(path);
will(returnValue(false));
allowing(fs).getName(path);
will(returnValue(fileName));
}
});
Book item = (Book) extractor.get(path);
assertThat(item.name, hasWords(seriesName));
}
/**
* Validates the given entry name by removing different slashes that might appear in the begining
* of the name and any occurences of relative paths like "../", so we can protect from path
* traversal attacks
*
* @param entryName Name of zip entry
*/
private static String validateEntryName(String entryName) {
entryName = FilenameUtils.separatorsToUnix(entryName);
entryName = PathUtils.trimLeadingSlashes(entryName);
entryName = removeDotSegments(entryName);
return entryName;
}
public static String makeTempFilePath(String cmd) throws UnsupportedEncodingException {
String dir_path = PathUtils.getTempFolderPath() + File.separator + ParamCommons.SERVICE_PORT;
File dir = new File(dir_path);
if (!dir.exists()) {
dir.mkdirs();
}
return dir_path + File.separator + MD5Utils.MD5Hash(cmd, charCode) + ".sh";
}
@Test
public void validatePathTest() throws InvalidPathException {
// check valid paths
PathUtils.validatePath("/foo/bar");
PathUtils.validatePath("/foo/bar/");
PathUtils.validatePath("/foo/./bar/");
PathUtils.validatePath("/foo/././bar/");
PathUtils.validatePath("/foo/../bar");
PathUtils.validatePath("/foo/../bar/");
// check invalid paths
LinkedList<String> invalidPaths = new LinkedList<String>();
invalidPaths.add(null);
invalidPaths.add("");
invalidPaths.add(" /");
invalidPaths.add("/ ");
for (String invalidPath : invalidPaths) {
try {
PathUtils.validatePath(invalidPath);
Assert.fail("validatePath(" + invalidPath + ") did not fail");
} catch (InvalidPathException ipe) {
// this is expected
}
}
}
@Test
public void getParentTest() throws InvalidPathException {
// get a parent that is non-root
Assert.assertEquals("/foo", PathUtils.getParent("/foo/bar"));
Assert.assertEquals("/foo", PathUtils.getParent("/foo/bar/"));
Assert.assertEquals("/foo", PathUtils.getParent("/foo/./bar/"));
Assert.assertEquals("/foo", PathUtils.getParent("/foo/././bar/"));
// get a parent that is root
Assert.assertEquals("/", PathUtils.getParent("/foo"));
Assert.assertEquals("/", PathUtils.getParent("/foo/bar/../"));
Assert.assertEquals("/", PathUtils.getParent("/foo/../bar/"));
// get parent of root
Assert.assertEquals("/", PathUtils.getParent("/"));
Assert.assertEquals("/", PathUtils.getParent("/foo/bar/../../"));
Assert.assertEquals("/", PathUtils.getParent("/foo/../bar/../"));
}
/**
* Creates the local block path and all the parent directories. Also, sets the appropriate
* permissions.
*
* @param path The path of the block.
* @throws IOException when fails to create block path and parent directories with appropriate
* permissions.
*/
public static void createBlockPath(String path) throws IOException {
try {
createStorageDirPath(PathUtils.getParent(path));
} catch (InvalidPathException e) {
throw new IOException("Failed to create block path, get parent path of " + path + "failed");
} catch (IOException ioe) {
throw new IOException("Failed to create block path " + path);
}
}
@Test
public void backupFile() throws IOException {
Path dirToBkp = Files.createTempDirectory("dirToBkp3");
Path parentdirfile1 = createTempFile(dirToBkp, "FILE_1", ".tmp");
new BackupHelper(conf).backupFile(parentdirfile1);
Path bkp = PathUtils.get(conf.getBackupDir(), parentdirfile1);
assertThat(exists(bkp), is(true));
}
/**
* get archive input stream from File Object
*
* @param sourceArchive - archive File
* @return archive input stream
* @throws IOException
*/
private static ArchiveInputStream createArchiveInputStream(File sourceArchive)
throws IOException {
String fileName = sourceArchive.getName();
String extension = PathUtils.getExtension(fileName);
verifySupportedExtension(extension);
FileInputStream fis = new FileInputStream(sourceArchive);
ArchiveInputStream archiveInputStream = returnArchiveInputStream(fis, extension);
if (archiveInputStream != null) {
return archiveInputStream;
}
throw new IllegalArgumentException("Unsupported archive extension: '" + extension + "'");
}
private void write(Object part, int id, Vector vector) throws IOException {
SequenceFile.Writer writer = writers.get(part);
if (writer == null) {
Configuration conf = UDFContext.getUDFContext().getJobConf();
Path file = PathUtils.enter(getStorePath(), String.valueOf(part), "part-" + Env.getPartID());
writer = IOUtils.forSequenceWrite(conf, file, IntWritable.class, VectorWritable.class);
writers.put(part, writer);
}
keyWritable.set(id);
valueWritable.set(vector);
writer.append(keyWritable, valueWritable);
}
/** Test of isRemote method, of class PathUtils. */
public void testIsRemote() {
System.out.println("isRemote");
assertTrue(PathUtils.isRemote("http://www.seznam.cz"));
assertTrue(PathUtils.isRemote("https://is.muni.cz/auth/more/data"));
assertTrue(PathUtils.isRemote("ftp://server"));
assertFalse(PathUtils.isRemote("relative/path"));
assertFalse(PathUtils.isRemote("relative"));
assertFalse(PathUtils.isRemote("/absolute/path"));
assertFalse(PathUtils.isRemote("./../../data.txt"));
}
public void remove(Stack stack) {
Collection<AbsFile> files = this.files.getValue(stack);
String dir = this.dir.getValue(stack);
Object host = this.host.getValue(stack);
VDLFileCache cache = getCache(stack);
List<Object> rem = new ArrayList<Object>();
boolean force = this.force.getValue(stack);
for (AbsFile f : files) {
File cf = new File(f.getName(), dircat(dir, PathUtils.remoteDirName(f)), host, 0);
CacheReturn cr = cache.unlockEntry(cf, force);
rem.addAll(cr.remove);
}
cacheFilesToRemove.setValue(stack, rem);
}
@Test
public void getPathComponentsNoExceptionTest() throws InvalidPathException {
Assert.assertArrayEquals(new String[] {""}, PathUtils.getPathComponents("/"));
Assert.assertArrayEquals(new String[] {"", "bar"}, PathUtils.getPathComponents("/bar"));
Assert.assertArrayEquals(
new String[] {"", "foo", "bar"}, PathUtils.getPathComponents("/foo/bar"));
Assert.assertArrayEquals(
new String[] {"", "foo", "bar"}, PathUtils.getPathComponents("/foo/bar/"));
Assert.assertArrayEquals(new String[] {"", "bar"}, PathUtils.getPathComponents("/foo/../bar"));
Assert.assertArrayEquals(
new String[] {"", "foo", "bar", "a", "b", "c"},
PathUtils.getPathComponents("/foo//bar/a/b/c"));
}
/** Test of relativizeFolders method, of class PathUtils. */
public void testGetParent() {
System.out.println("testGetParent");
Path result = PathUtils.getParent(Paths.get(""));
assertEquals(Paths.get(""), result);
result = PathUtils.getParent(Paths.get("import.lesscache"));
assertEquals(Paths.get(""), result);
result = PathUtils.getParent(Paths.get("path/import.lesscache"));
assertEquals(Paths.get("path"), result);
result = PathUtils.getParent(Paths.get("base/path/import.lesscache"));
assertEquals(Paths.get("base/path"), result);
result = PathUtils.getParent(Paths.get("../file.lesscache"));
assertEquals(Paths.get(".."), result);
result = PathUtils.getParent(Paths.get("../../file.lesscache"));
assertEquals(Paths.get("../.."), result);
result = PathUtils.getParent(Paths.get("../other/file.lesscache"));
assertEquals(Paths.get("../other"), result);
}
/**
* Searches for an entry inside the zip stream by entry path. If there are alternative extensions,
* will also look for entry with alternative extension. The search stops reading the stream when
* the entry is found, so calling read on the stream will read the returned entry.
*
* <p>The zip input stream doesn't support mark/reset so once this method is used you cannot go
* back - either the stream was fully read (when entry is not found) or the stream was read until
* the current entry.
*
* @param zis The zip input stream
* @param entryPath The entry path to search for
* @param alternativeExtensions List of alternative file extensions to try if the main entry path
* is not found.
* @return The entry if found, null otherwise
* @throws IOException On failure to read the stream
*/
public static ZipEntry locateEntry(
ZipInputStream zis, String entryPath, List<String> alternativeExtensions) throws IOException {
ZipEntry zipEntry;
while ((zipEntry = zis.getNextEntry()) != null) {
String zipEntryName = zipEntry.getName();
if (zipEntryName.equals(entryPath)) {
return zipEntry;
} else if (alternativeExtensions != null) {
String basePath = PathUtils.stripExtension(entryPath);
for (String alternativeExtension : alternativeExtensions) {
String alternativeSourcePath = basePath + "." + alternativeExtension;
if (zipEntryName.equals(alternativeSourcePath)) {
return zipEntry;
}
}
}
}
return null;
}
@Test
public void authorFolderPathReturnsAuthorObjectWithProperName() throws Exception {
final String author = "Лукьяненко Сергей";
final String path = PathUtils.createPath("ru", "Л", author);
mockery.checking(
new Expectations() {
{
allowing(fs).exists(path);
will(returnValue(true));
allowing(fs).isDirectory(path);
will(returnValue(true));
allowing(fs).getName(path);
will(returnValue(author));
}
});
Author item = (Author) extractor.get(path);
assertThat(item, equalTo(new Author(path, author)));
}
@Test
public void underscoreFolderPathReturnsFolder() throws Exception {
final String folderName = "_scifi";
final String path = PathUtils.createPath("ru", "_", folderName);
mockery.checking(
new Expectations() {
{
allowing(fs).exists(path);
will(returnValue(true));
allowing(fs).isDirectory(path);
will(returnValue(true));
allowing(fs).getName(path);
will(returnValue(folderName));
}
});
Folder item = (Folder) extractor.get(path);
assertThat(item, equalTo(new Folder(path, folderName)));
}
@Test
public void bookFilePathReturnsBookItemWithProperName() throws Exception {
String author = "Лукьяненко Сергей";
String bookName = "Геном";
final String fileName = bookName + ".fb2.zip";
final String path = PathUtils.createPath("ru", "Л", author, fileName);
mockery.checking(
new Expectations() {
{
allowing(fs).exists(path);
will(returnValue(true));
allowing(fs).isDirectory(path);
will(returnValue(false));
allowing(fs).getName(path);
will(returnValue(fileName));
}
});
Book item = (Book) extractor.get(path);
assertThat(item, equalTo(new Book(path, bookName)));
}
@Test(expected = PathTraversalException.class)
public void dotDotShouldBeDisallowedIfOutsideSecureDir() throws Exception {
PathUtils.ensurePathInSecureDir(tmpDir, new File(tmpDir, "../").getPath()); // ${tmpDir}/..
}
@Test
public void dotDotShouldBeAllowedIfInsideSecureDir() throws Exception {
PathUtils.ensurePathInSecureDir(
tmpDir, new File(tmpDir, "a/b/../b").getAbsolutePath()); // ${tmpDir}/a/b
}
public FilePath getParentDirectory() {
return new FilePath(PathUtils.getDirectoryName(this.asString()));
}
@Test
public void cleanPathNoExceptionTest() throws InvalidPathException {
// test clean path
Assert.assertEquals("/foo/bar", PathUtils.cleanPath("/foo/bar"));
// test trailing slash
Assert.assertEquals("/foo/bar", PathUtils.cleanPath("/foo/bar/"));
// test redundant slashes
Assert.assertEquals("/foo/bar", PathUtils.cleanPath("/foo//bar"));
Assert.assertEquals("/foo/bar", PathUtils.cleanPath("/foo//bar//"));
Assert.assertEquals("/foo/bar", PathUtils.cleanPath("/foo///////bar//////"));
// test dots gets resolved
Assert.assertEquals("/foo/bar", PathUtils.cleanPath("/foo/./bar"));
Assert.assertEquals("/foo/bar", PathUtils.cleanPath("/foo/././bar"));
Assert.assertEquals("/foo", PathUtils.cleanPath("/foo/bar/.."));
Assert.assertEquals("/bar", PathUtils.cleanPath("/foo/../bar"));
Assert.assertEquals("/", PathUtils.cleanPath("/foo/bar/../.."));
// the following seems strange
// TODO(jiri): Instead of returning null, throw InvalidPathException.
Assert.assertNull(PathUtils.cleanPath("/foo/bar/../../.."));
}
@Test
public void getPathComponentsExceptionTest() throws InvalidPathException {
mException.expect(InvalidPathException.class);
PathUtils.getPathComponents("/\\ foo / bar");
}
@Test
public void uniqPathTest() {
Assert.assertNotEquals(PathUtils.uniqPath(), PathUtils.uniqPath());
}
@Test
public void backupComplexDir() throws IOException {
Path dirToBkp = Files.createTempDirectory("dirToBkp4");
Path subDir1 = Files.createTempDirectory(dirToBkp, "subDir1");
Path subDir2 = Files.createTempDirectory(dirToBkp, "subDir2");
Path subDir3 = Files.createTempDirectory(subDir1, "subDir3");
Path parentdirfile1 = createTempFile(dirToBkp, "FILE_1", ".tmp");
Path parentdirfile2 = createTempFile(subDir1, "FILE_2", ".tmp");
Path parentdirfile3 = createTempFile(subDir3, "FILE_3", ".tmp");
new BackupHelper(conf).backupFileOrDir(dirToBkp);
Path bkp = PathUtils.get(conf.getBackupDir(), dirToBkp);
assertThat(exists(bkp), is(true));
assertThat(exists(PathUtils.get(bkp, parentdirfile1.getFileName())), is(true));
assertThat(exists(PathUtils.get(bkp, subDir1.getFileName())), is(true));
assertThat(exists(PathUtils.get(bkp, subDir2.getFileName())), is(true));
assertThat(
exists(
PathUtils.get(PathUtils.get(bkp, subDir1.getFileName()), parentdirfile2.getFileName())),
is(true));
assertThat(
exists(PathUtils.get(PathUtils.get(bkp, subDir1.getFileName()), subDir3.getFileName())),
is(true));
assertThat(
exists(
PathUtils.get(
PathUtils.get(PathUtils.get(bkp, subDir1.getFileName()), subDir3.getFileName()),
parentdirfile3.getFileName())),
is(true));
}
@Test
public void concatPathTest() {
Assert.assertEquals("/", PathUtils.concatPath("/"));
Assert.assertEquals("/", PathUtils.concatPath("/", ""));
Assert.assertEquals("/bar", PathUtils.concatPath("/", "bar"));
Assert.assertEquals("foo", PathUtils.concatPath("foo"));
Assert.assertEquals("/foo", PathUtils.concatPath("/foo"));
Assert.assertEquals("/foo", PathUtils.concatPath("/foo", ""));
// Join base without trailing "/"
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo", "bar"));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo", "bar/"));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo", "/bar"));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo", "/bar/"));
// Join base with trailing "/"
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo/", "bar"));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo/", "bar/"));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo/", "/bar"));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo/", "/bar/"));
// Whitespace must be trimmed.
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo ", "bar "));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo ", " bar"));
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo ", " bar "));
// Redundant separator must be trimmed.
Assert.assertEquals("/foo/bar", PathUtils.concatPath("/foo/", "bar//"));
// Multiple components to join.
Assert.assertEquals("/foo/bar/a/b/c", PathUtils.concatPath("/foo", "bar", "a", "b", "c"));
Assert.assertEquals("/foo/bar/b/c", PathUtils.concatPath("/foo", "bar", "", "b", "c"));
// Non-string
Assert.assertEquals("/foo/bar/1", PathUtils.concatPath("/foo", "bar", 1));
Assert.assertEquals("/foo/bar/2", PathUtils.concatPath("/foo", "bar", 2L));
// Header
Assert.assertEquals(
Constants.HEADER + "host:port/foo/bar",
PathUtils.concatPath(Constants.HEADER + "host:port", "/foo", "bar"));
}
