| // Copyright 2014 Google Inc. |
| // |
| // 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. |
| |
| package com.google.enterprise.adaptor.fs; |
| |
| import static org.junit.Assert.*; |
| |
| import com.google.common.base.Charsets; |
| import com.google.common.io.CharStreams; |
| |
| import org.junit.*; |
| import org.junit.rules.ExpectedException; |
| |
| import java.io.FileNotFoundException; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.InputStreamReader; |
| import java.nio.file.attribute.BasicFileAttributes; |
| import java.nio.file.attribute.FileTime; |
| import java.nio.file.DirectoryStream; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.Iterator; |
| |
| /** |
| * Test cases for {@link MockFile}. |
| */ |
| public class MockFileTest { |
| |
| private static final FileTime createTime = FileTime.fromMillis(20000); |
| private static final FileTime modifyTime = FileTime.fromMillis(30000); |
| private static final FileTime accessTime = FileTime.fromMillis(40000); |
| |
| @Rule |
| public ExpectedException thrown = ExpectedException.none(); |
| |
| @Test |
| public void testConstructorNullName() throws Exception { |
| thrown.expect(NullPointerException.class); |
| new MockFile(null); |
| } |
| |
| /** Test constructor for regular files. */ |
| @Test |
| public void testFileConstructor() throws Exception { |
| MockFile f = new MockFile("test"); |
| checkDefaultConfig(f, "test", false); |
| assertEquals("Contents of test", readContents(f)); |
| assertEquals("text/plain", f.getContentType()); |
| } |
| |
| /** Test constructor for directories . */ |
| @Test |
| public void testDirectoryConstructor() throws Exception { |
| MockFile f = new MockFile("test", true); |
| checkDefaultConfig(f, "test", true); |
| DirectoryStream<Path> ds = f.newDirectoryStream(); |
| assertNotNull(ds); |
| assertFalse(ds.iterator().hasNext()); |
| ds.close(); |
| } |
| |
| /** |
| * Verifies some of the default file attributes (no explicit setters called). |
| */ |
| private void checkDefaultConfig(MockFile file, String name, boolean isDir) |
| throws Exception { |
| assertEquals(name, file.getName()); |
| assertEquals(isDir, file.isDirectory()); |
| assertEquals(!isDir, file.isRegularFile()); |
| assertFalse(file.isHidden()); |
| assertNull(file.getParent()); |
| assertEquals(MockFile.DEFAULT_FILETIME, file.getCreationTime()); |
| assertEquals(MockFile.DEFAULT_FILETIME, file.getLastModifiedTime()); |
| assertEquals(MockFile.DEFAULT_FILETIME, file.getLastAccessTime()); |
| } |
| |
| private String readContents(MockFile file) throws IOException { |
| return CharStreams.toString( |
| new InputStreamReader(file.newInputStream(), Charsets.UTF_8)); |
| } |
| |
| @Test |
| public void testSetName() throws Exception { |
| assertEquals("foo", new MockFile("test").setName("foo").getName()); |
| } |
| |
| @Test |
| public void testSetIsRegularFile() throws Exception { |
| MockFile f = new MockFile("test").setIsRegularFile(false); |
| assertFalse(f.isRegularFile()); |
| assertFalse(f.isDirectory()); |
| |
| f.setIsRegularFile(true); |
| assertTrue(f.isRegularFile()); |
| assertFalse(f.isDirectory()); |
| } |
| |
| @Test |
| public void testSetIsHidden() throws Exception { |
| MockFile f = new MockFile("test"); |
| assertFalse(f.isHidden()); // default is false. |
| assertTrue(f.setIsHidden(true).isHidden()); |
| assertFalse(f.setIsHidden(false).isHidden()); |
| } |
| |
| @Test |
| public void testSetFileTimes() throws Exception { |
| MockFile f = new MockFile("test").setCreationTime(createTime) |
| .setLastModifiedTime(modifyTime).setLastAccessTime(accessTime); |
| assertEquals(createTime, f.getCreationTime()); |
| assertEquals(modifyTime, f.getLastModifiedTime()); |
| assertEquals(accessTime, f.getLastAccessTime()); |
| } |
| |
| @Test |
| public void testReadBasicAttributesRegularFile() throws Exception { |
| MockFile f = new MockFile("test").setCreationTime(createTime) |
| .setLastModifiedTime(modifyTime).setLastAccessTime(accessTime); |
| |
| BasicFileAttributes bfa = f.readBasicAttributes(); |
| assertNotNull(bfa); |
| assertSame(f, bfa.fileKey()); |
| assertEquals(createTime, bfa.creationTime()); |
| assertEquals(modifyTime, bfa.lastModifiedTime()); |
| assertEquals(accessTime, bfa.lastAccessTime()); |
| assertTrue(bfa.isRegularFile()); |
| assertFalse(bfa.isDirectory()); |
| assertFalse(bfa.isSymbolicLink()); |
| assertFalse(bfa.isOther()); |
| assertEquals(readContents(f).length(), bfa.size()); |
| } |
| |
| @Test |
| public void testReadBasicAttributesDirectory() throws Exception { |
| MockFile f = new MockFile("test", true).setCreationTime(createTime) |
| .setLastModifiedTime(modifyTime).setLastAccessTime(accessTime); |
| |
| BasicFileAttributes bfa = f.readBasicAttributes(); |
| assertNotNull(bfa); |
| assertSame(f, bfa.fileKey()); |
| assertEquals(createTime, bfa.creationTime()); |
| assertEquals(modifyTime, bfa.lastModifiedTime()); |
| assertEquals(accessTime, bfa.lastAccessTime()); |
| assertFalse(bfa.isRegularFile()); |
| assertTrue(bfa.isDirectory()); |
| assertFalse(bfa.isSymbolicLink()); |
| assertFalse(bfa.isOther()); |
| assertEquals(0L, bfa.size()); |
| } |
| |
| @Test |
| public void testReadBasicAttributesSpecialFile() throws Exception { |
| // If neither file, nor directory, then it is "special". |
| MockFile f = new MockFile("test", false).setIsRegularFile(false); |
| BasicFileAttributes bfa = f.readBasicAttributes(); |
| assertFalse(bfa.isRegularFile()); |
| assertFalse(bfa.isDirectory()); |
| assertFalse(bfa.isSymbolicLink()); |
| assertTrue(bfa.isOther()); |
| assertEquals(0L, bfa.size()); |
| } |
| |
| @Test |
| public void testSetFileContents() throws Exception { |
| String expected = "Hello World"; |
| MockFile f = new MockFile("test.txt").setFileContents(expected); |
| assertEquals(expected, readContents(f)); |
| } |
| |
| @Test |
| public void testSetFileContentsBytes() throws Exception { |
| String expected = "<html><title>Hello World</title></html>"; |
| MockFile f = new MockFile("test.html") |
| .setFileContents(expected.getBytes(Charsets.UTF_8)) |
| .setContentType("text/html"); |
| assertEquals(expected, readContents(f)); |
| assertEquals("text/html", f.getContentType()); |
| } |
| |
| @Test |
| public void testChildren() throws Exception { |
| MockFile root = new MockFile("root", true); |
| MockFile dir1 = new MockFile("dir1", true); |
| MockFile dir2 = new MockFile("dir2", true); |
| MockFile test = new MockFile("test.txt"); |
| root.addChildren(test, dir1, dir2); |
| assertNull(root.getParent()); |
| assertSame(root, dir1.getParent()); |
| assertSame(root, dir2.getParent()); |
| assertSame(root, test.getParent()); |
| checkDirectoryListing(root, dir1, dir2, test); |
| |
| // Test getChild(). |
| assertSame(dir1, root.getChild("dir1")); |
| assertSame(dir2, root.getChild("dir2")); |
| assertSame(test, root.getChild("test.txt")); |
| |
| // Add another file. |
| MockFile newer = new MockFile("newer.txt"); |
| root.addChildren(newer); |
| checkDirectoryListing(root, dir1, dir2, newer, test); |
| } |
| |
| private void checkDirectoryListing(MockFile parent, MockFile... children) |
| throws IOException { |
| DirectoryStream<Path> ds = parent.newDirectoryStream(); |
| assertNotNull(ds); |
| Iterator<Path> iter = ds.iterator(); |
| assertNotNull(iter); |
| for (MockFile child : children) { |
| assertEquals(child.getName(), iter.next().getFileName().toString()); |
| } |
| assertFalse(iter.hasNext()); |
| ds.close(); |
| } |
| |
| @Test |
| public void testGetPath() throws Exception { |
| MockFile root = new MockFile("root", true); |
| MockFile dir1 = new MockFile("dir1", true); |
| MockFile test = new MockFile("test.txt"); |
| MockFile test1 = new MockFile("test.txt"); |
| root.addChildren(test, dir1); |
| dir1.addChildren(test1); |
| assertEquals("root", root.getPath()); |
| assertEquals("root/dir1", dir1.getPath()); |
| assertEquals("root/test.txt", test.getPath()); |
| assertEquals("root/dir1/test.txt", test1.getPath()); |
| } |
| |
| @Test |
| public void testGetChildNullName() throws Exception { |
| thrown.expect(NullPointerException.class); |
| new MockFile("root", true).getChild(null); |
| } |
| |
| @Test |
| public void testGetChildNotFound() throws Exception { |
| thrown.expect(FileNotFoundException.class); |
| new MockFile("root", true).getChild("nonExistent"); |
| } |
| |
| @Test |
| public void testGetDfsUncActiveStorageUnc() throws Exception { |
| MockFile root = new MockFile("root", true); |
| assertNull(root.getDfsUncActiveStorageUnc()); |
| Path uncPath = Paths.get("\\\\server\\share"); |
| root.setDfsUncActiveStorageUnc(uncPath); |
| assertEquals(uncPath, root.getDfsUncActiveStorageUnc()); |
| } |
| |
| @Test |
| public void testGetDfsShareAclView() throws Exception { |
| MockFile root = new MockFile("root", true); |
| assertNull(root.getDfsShareAclView()); |
| root.setDfsShareAclView(MockFile.FULL_ACCESS_ACLVIEW); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, root.getDfsShareAclView()); |
| } |
| |
| @Test |
| public void testDefaultRootAclViews() throws Exception { |
| MockFile root = new MockFile("root", true); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, root.getShareAclView()); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, root.getAclView()); |
| assertEquals(MockFile.EMPTY_ACLVIEW, root.getInheritedAclView()); |
| } |
| |
| @Test |
| public void testDefaultNonRootAclViews() throws Exception { |
| MockFile root = new MockFile("root", true); |
| MockFile dir1 = new MockFile("dir1", true); |
| MockFile foo = new MockFile("foo"); |
| MockFile bar = new MockFile("bar"); |
| root.addChildren(dir1, foo); |
| dir1.addChildren(bar); |
| assertEquals(MockFile.EMPTY_ACLVIEW, dir1.getAclView()); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, dir1.getInheritedAclView()); |
| assertEquals(MockFile.EMPTY_ACLVIEW, foo.getAclView()); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, foo.getInheritedAclView()); |
| assertEquals(MockFile.EMPTY_ACLVIEW, bar.getAclView()); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, bar.getInheritedAclView()); |
| } |
| |
| @Test |
| public void testSetAclViews() throws Exception { |
| MockFile root = new MockFile("root", true); |
| MockFile foo = new MockFile("foo"); |
| root.addChildren(foo); |
| assertEquals(MockFile.EMPTY_ACLVIEW, foo.getAclView()); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, foo.getInheritedAclView()); |
| |
| foo.setAclView(MockFile.FULL_ACCESS_ACLVIEW); |
| foo.setInheritedAclView(MockFile.EMPTY_ACLVIEW); |
| assertEquals(MockFile.FULL_ACCESS_ACLVIEW, foo.getAclView()); |
| assertEquals(MockFile.EMPTY_ACLVIEW, foo.getInheritedAclView()); |
| } |
| } |