Merge branch 'master' of https://code.google.com/p/plexi.fs into FixShareAcl2
Conflicts:
src/com/google/enterprise/adaptor/fs/FsAdaptor.java
test/com/google/enterprise/adaptor/fs/FsAdaptorTest.java
diff --git a/src/com/google/enterprise/adaptor/fs/FsAdaptor.java b/src/com/google/enterprise/adaptor/fs/FsAdaptor.java
index 972cc84..d8a6103 100644
--- a/src/com/google/enterprise/adaptor/fs/FsAdaptor.java
+++ b/src/com/google/enterprise/adaptor/fs/FsAdaptor.java
@@ -134,13 +134,15 @@
/** The namespace applied to ACL Principals. */
private String namespace;
+ /** The filesystem change monitor. */
+ private FsMonitor monitor;
+
private AdaptorContext context;
private Path rootPath;
private boolean isDfsUnc;
private DocId rootPathDocId;
private FileDelegate delegate;
- private FsMonitor monitor;
- private ShareAcls lastPushedShareAcls = new ShareAcls(null, null);
+ private ShareAcls lastPushedShareAcls = null;
public FsAdaptor() {
// At the moment, we only support Windows.
@@ -152,6 +154,31 @@
}
}
+ @VisibleForTesting
+ FsAdaptor(FileDelegate delegate) {
+ this.delegate = delegate;
+ }
+
+ @VisibleForTesting
+ Set<String> getSupportedWindowsAccounts() {
+ return supportedWindowsAccounts;
+ }
+
+ @VisibleForTesting
+ String getBuiltinPrefix() {
+ return builtinPrefix;
+ }
+
+ @VisibleForTesting
+ String getNamespace() {
+ return namespace;
+ }
+
+ @VisibleForTesting
+ BlockingQueue<Path> getFsMonitorQueue() {
+ return monitor.getQueue();
+ }
+
@Override
public void initConfig(Config config) {
config.addKey(CONFIG_SRC, null);
@@ -238,11 +265,16 @@
@Override
public void destroy() {
delegate.destroy();
- monitor.destroy();
- monitor = null;
+ // TODO (bmj): The check for null monitor is strictly for the tests,
+ // some of which may not have fully initialized the adaptor. Maybe
+ // look into handling this less obtrusively in the future.
+ if (monitor != null) {
+ monitor.destroy();
+ monitor = null;
+ }
}
- private ShareAcls getShareAcls() throws IOException {
+ private ShareAcls readShareAcls() throws IOException {
Acl shareAcl;
Acl dfsShareAcl;
@@ -305,14 +337,14 @@
// The pusher does not support fragments in named resources.
// Feed a DocId that is just the SHARE_ACL fragment to avoid
// collisions with the root docid.
- ShareAcls shareAcls = getShareAcls();
+ ShareAcls shareAcls = readShareAcls();
Map<DocId, Acl> namedResources = new HashMap<DocId, Acl>();
- if (forcePush || ((shareAcls.dfsShareAcl != null)
- && !shareAcls.dfsShareAcl.equals(lastPushedShareAcls.dfsShareAcl))) {
+ if ((shareAcls.dfsShareAcl != null) && (forcePush ||
+ !shareAcls.dfsShareAcl.equals(lastPushedShareAcls.dfsShareAcl))) {
namedResources.put(DFS_SHARE_ACL_DOCID, shareAcls.dfsShareAcl);
}
- if (forcePush || ((shareAcls.shareAcl != null)
- && !shareAcls.shareAcl.equals(lastPushedShareAcls.shareAcl))) {
+ if ((shareAcls.shareAcl != null) && (forcePush ||
+ !shareAcls.shareAcl.equals(lastPushedShareAcls.shareAcl))) {
namedResources.put(SHARE_ACL_DOCID, shareAcls.shareAcl);
}
if (namedResources.size() > 0) {
@@ -443,10 +475,10 @@
// Populate the document content.
if (docIsDirectory) {
HtmlResponseWriter writer = createHtmlResponseWriter(resp);
- writer.start(id, getPathName(doc));
+ writer.start(id, getFileName(doc));
for (Path file : delegate.newDirectoryStream(doc)) {
if (isSupportedPath(file)) {
- writer.addLink(delegate.newDocId(file), getPathName(file));
+ writer.addLink(delegate.newDocId(file), getFileName(file));
}
}
writer.finish();
@@ -483,12 +515,14 @@
}
@VisibleForTesting
- String getPathName(Path file) {
+ String getFileName(Path file) {
// NOTE: file.getFileName() fails for UNC paths. Use file.toFile() instead.
- return file.toFile().getName();
+ String name = file.toFile().getName();
+ return name.isEmpty() ? file.getRoot().toString() : name;
}
- private boolean isSupportedPath(Path p) throws IOException {
+ @VisibleForTesting
+ boolean isSupportedPath(Path p) throws IOException {
return delegate.isRegularFile(p) || delegate.isDirectory(p);
}
@@ -496,7 +530,8 @@
* Verifies that the file is a descendant of the root directory,
* and that it, nor none of its ancestors, is hidden.
*/
- private boolean isVisibleDescendantOfRoot(Path doc) throws IOException {
+ @VisibleForTesting
+ boolean isVisibleDescendantOfRoot(Path doc) throws IOException {
for (Path file = doc; file != null; file = file.getParent()) {
if (delegate.isHidden(file)) {
if (doc.equals(file)) {
@@ -531,8 +566,8 @@
Preconditions.checkNotNull(pusher, "the DocId pusher may not be null");
Preconditions.checkArgument(maxFeedSize > 0,
"the maxFeedSize must be greater than zero");
- Preconditions.checkArgument(maxLatencyMillis > 0,
- "the maxLatencyMillis must be greater than zero");
+ Preconditions.checkArgument(maxLatencyMillis >= 0,
+ "the maxLatencyMillis must be greater than or equal to zero");
this.pusher = pusher;
this.maxFeedSize = maxFeedSize;
this.maxLatencyMillis = maxLatencyMillis;
diff --git a/src/com/google/enterprise/adaptor/fs/HtmlResponseWriter.java b/src/com/google/enterprise/adaptor/fs/HtmlResponseWriter.java
index 3cf0f47..e0d50f3 100644
--- a/src/com/google/enterprise/adaptor/fs/HtmlResponseWriter.java
+++ b/src/com/google/enterprise/adaptor/fs/HtmlResponseWriter.java
@@ -15,6 +15,7 @@
package com.google.enterprise.adaptor.fs;
import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Strings;
import com.google.enterprise.adaptor.DocId;
import com.google.enterprise.adaptor.DocIdEncoder;
@@ -213,10 +214,10 @@
}
private String computeLabel(String label, DocId doc) {
- if (label == null || "".equals(label)) {
+ if (Strings.isNullOrEmpty(label)) {
// Use the last part of the URL if an item doesn't have a title. The last
// part of the URL will generally be a filename in this case.
- String[] parts = doc.getUniqueId().split("/");
+ String[] parts = doc.getUniqueId().split("/", 0);
label = parts[parts.length - 1];
}
return label;
diff --git a/src/com/google/enterprise/adaptor/fs/WindowsAclFileAttributeViews.java b/src/com/google/enterprise/adaptor/fs/WindowsAclFileAttributeViews.java
index 199b568..b70e455 100644
--- a/src/com/google/enterprise/adaptor/fs/WindowsAclFileAttributeViews.java
+++ b/src/com/google/enterprise/adaptor/fs/WindowsAclFileAttributeViews.java
@@ -14,6 +14,7 @@
package com.google.enterprise.adaptor.fs;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
@@ -67,12 +68,9 @@
*/
class WindowsAclFileAttributeViews {
- private static final Logger log =
+ private static final Logger log =
Logger.getLogger(WindowsAclFileAttributeViews.class.getName());
- private static final Kernel32 KERNEL32 = Kernel32.INSTANCE;
- private static final Advapi32 ADVAPI32 = Advapi32.INSTANCE;
-
/** This pattern parses a UNC path to get the host and share details. */
private static final Pattern UNC_PATTERN =
Pattern.compile("^\\\\\\\\([^\\\\]+)\\\\([^\\\\]+)");
@@ -88,7 +86,7 @@
Collections.unmodifiableSet(Sets.newHashSet(SID_NAME_USE.SidTypeUser));
/** Map of NT GENERIC permissions to NT FILE permissions. */
- private static final Map<Integer, Integer> GENERIC_PERMS_MAP =
+ private static final Map<Integer, Integer> GENERIC_PERMS_MAP =
Collections.unmodifiableMap(new HashMap<Integer, Integer>() {
{
put(WinNT.GENERIC_READ, WinNT.FILE_GENERIC_READ);
@@ -142,6 +140,28 @@
}
});
+ private final Advapi32 advapi32;
+ private final Kernel32 kernel32;
+ private final Mpr mpr;
+ private final Netapi32Ex netapi32;
+ private final Shlwapi shlwapi;
+
+ /** Constructor used for production. */
+ public WindowsAclFileAttributeViews() {
+ this(Advapi32.INSTANCE, Kernel32.INSTANCE, Mpr.INSTANCE,
+ Netapi32Ex.INSTANCE,Shlwapi.INSTANCE);
+ }
+
+ /** Constructor used by the tests. */
+ @VisibleForTesting
+ WindowsAclFileAttributeViews(Advapi32 advapi32, Kernel32 kernel32,
+ Mpr mpr, Netapi32Ex netapi32, Shlwapi shlwapi) {
+ this.advapi32 = advapi32;
+ this.kernel32 = kernel32;
+ this.mpr = mpr;
+ this.netapi32 = netapi32;
+ this.shlwapi = shlwapi;
+ }
/**
* Returns a container for the direct and inherited ACLs for
@@ -152,7 +172,7 @@
*/
public AclFileAttributeViews getAclViews(Path path) throws IOException {
String pathname = path.toRealPath(LinkOption.NOFOLLOW_LINKS).toString();
- WinNT.ACCESS_ACEStructure[] aces = getFileSecurity(pathname,
+ WinNT.ACCESS_ACEStructure[] aces = getFileSecurity(pathname,
WinNT.DACL_SECURITY_INFORMATION |
WinNT.PROTECTED_DACL_SECURITY_INFORMATION |
WinNT.UNPROTECTED_DACL_SECURITY_INFORMATION);
@@ -160,7 +180,7 @@
ImmutableList.Builder<AclEntry> direct = ImmutableList.builder();
for (WinNT.ACCESS_ACEStructure ace : aces) {
- AclEntry aclEntry = newAclEntry(ace);
+ AclEntry aclEntry = newAclEntry(ace);
if (aclEntry != null) {
if ((ace.AceFlags & WinNT.INHERITED_ACE) == WinNT.INHERITED_ACE) {
inherited.add(aclEntry);
@@ -192,23 +212,22 @@
*/
public AclFileAttributeView getShareAclView(Path path)
throws IOException, UnsupportedOperationException {
- if (Shlwapi.INSTANCE.PathIsUNC(path.toString())) {
+ if (shlwapi.PathIsUNC(path.toString())) {
log.log(Level.FINEST, "Using a UNC path.");
return getUncShareAclView(path.toString());
- } else if (Shlwapi.INSTANCE.PathIsNetworkPath(path.toString())) {
+ } else if (shlwapi.PathIsNetworkPath(path.toString())) {
log.log(Level.FINEST, "Using a mapped drive.");
- // Call WNetGetUniversalNameW with the size needed for
+ // Call WNetGetUniversalNameW with the size needed for
// UNIVERSAL_NAME_INFO. If WNetGetUniversalNameW returns ERROR_MORE_DATA
// that indicates that a larger buffer is needed. If this happens, make
// a second call to WNetGetUniversalNameW with a buffer big enough.
- Mpr mprlib = Mpr.INSTANCE;
Memory buf = new Memory(1024);
IntByReference bufSize = new IntByReference((int) buf.size());
- int result = mprlib.WNetGetUniversalNameW(path.getRoot().toString(),
+ int result = mpr.WNetGetUniversalNameW(path.getRoot().toString(),
Mpr.UNIVERSAL_NAME_INFO_LEVEL, buf, bufSize);
if (result == WinNT.ERROR_MORE_DATA) {
buf = new Memory(bufSize.getValue());
- result = Mpr.INSTANCE.WNetGetUniversalNameW(path.getRoot().toString(),
+ result = mpr.WNetGetUniversalNameW(path.getRoot().toString(),
Mpr.UNIVERSAL_NAME_INFO_LEVEL, buf, bufSize);
}
if (result != WinNT.NO_ERROR) {
@@ -239,12 +258,11 @@
new Object[] { host, share });
return getShareAclView(host, share);
}
-
+
private AclFileAttributeView getShareAclView(String host, String share)
throws IOException {
- Netapi32Ex netapi32 = Netapi32Ex.INSTANCE;
PointerByReference buf = new PointerByReference();
-
+
// Call NetShareGetInfo with a 502 to get the security descriptor of the
// share. The security descriptor contains the Acl details for the share
// that the adaptor needs.
@@ -299,7 +317,7 @@
* @return AclEntry representing the ace, or {@code null} if a valid
* AclEntry could not be created from the ace.
*/
- public static AclEntry newAclEntry(WinNT.ACCESS_ACEStructure ace) {
+ public AclEntry newAclEntry(WinNT.ACCESS_ACEStructure ace) {
// Map the type.
AclEntryType aclType = ACL_TYPE_MAP.get(ace.AceType);
if (aclType == null) {
@@ -311,7 +329,7 @@
// Map the user.
Account account;
try {
- account = Advapi32Util.getAccountBySid(ace.getSID());
+ account = getAccountBySid(ace.getSID());
} catch (Win32Exception e) {
// Only the least significant 16-bits signifies the HR code.
if ((e.getHR().intValue() & 0xFFFF) == WinError.ERROR_NONE_MAPPED) {
@@ -336,7 +354,7 @@
new Object[] { accountName, accountType });
return null;
}
-
+
// Expand NT GENERIC_* permissions to their FILE_GENERIC_* equivalents.
int aceMask = ace.Mask;
for (Map.Entry<Integer, Integer> e : GENERIC_PERMS_MAP.entrySet()) {
@@ -352,7 +370,7 @@
aclPerms.add(e.getValue());
}
}
-
+
// Map the flags.
Set<AclEntryFlag> aclFlags = EnumSet.noneOf(AclEntryFlag.class);
for (Map.Entry<Byte, AclEntryFlag> e : ACL_FLAGS_MAP.entrySet()) {
@@ -369,6 +387,11 @@
.build();
}
+ @VisibleForTesting
+ Account getAccountBySid(WinNT.PSID sid) throws Win32Exception {
+ return Advapi32Util.getAccountBySid(sid);
+ }
+
// One-to-one corresponance to WinNT.SID_NAME_USE "enumeration".
private static final List<String> SID_TYPE_NAMES = ImmutableList.of(
"Unknown", "User", "Group", "Domain", "Alias", "Well-known Group",
@@ -408,7 +431,8 @@
}
}
- private interface Mpr extends StdCallLibrary {
+ @VisibleForTesting
+ interface Mpr extends StdCallLibrary {
Mpr INSTANCE = (Mpr) Native.loadLibrary("Mpr", Mpr.class,
W32APIOptions.UNICODE_OPTIONS);
@@ -442,21 +466,21 @@
WString wpath = new WString(pathname);
IntByReference lengthNeeded = new IntByReference();
- if (ADVAPI32.GetFileSecurity(wpath, daclType, null, 0, lengthNeeded)) {
+ if (advapi32.GetFileSecurity(wpath, daclType, null, 0, lengthNeeded)) {
throw new RuntimeException("GetFileSecurity was expected to fail with "
+ "ERROR_INSUFFICIENT_BUFFER");
}
- int rc = KERNEL32.GetLastError();
+ int rc = kernel32.GetLastError();
if (rc != W32Errors.ERROR_INSUFFICIENT_BUFFER) {
throw new IOException("Failed GetFileSecurity", new Win32Exception(rc));
}
Memory memory = new Memory(lengthNeeded.getValue());
- if (!ADVAPI32.GetFileSecurity(wpath, daclType, memory, (int) memory.size(),
+ if (!advapi32.GetFileSecurity(wpath, daclType, memory, (int) memory.size(),
lengthNeeded)) {
throw new IOException("Failed GetFileSecurity",
- new Win32Exception(KERNEL32.GetLastError()));
+ new Win32Exception(kernel32.GetLastError()));
}
WinNT.SECURITY_DESCRIPTOR_RELATIVE securityDescriptor =
diff --git a/src/com/google/enterprise/adaptor/fs/WindowsFileDelegate.java b/src/com/google/enterprise/adaptor/fs/WindowsFileDelegate.java
index 18b139b..07c106d 100644
--- a/src/com/google/enterprise/adaptor/fs/WindowsFileDelegate.java
+++ b/src/com/google/enterprise/adaptor/fs/WindowsFileDelegate.java
@@ -99,7 +99,7 @@
ImmutableList.Builder<AclEntry> builder = ImmutableList.builder();
for (WinNT.ACCESS_ACEStructure ace : dacl.getACEStructures()) {
- AclEntry entry = WindowsAclFileAttributeViews.newAclEntry(ace);
+ AclEntry entry = aclViews.newAclEntry(ace);
if (entry != null) {
builder.add(entry);
}
diff --git a/test/com/google/enterprise/adaptor/fs/AccumulatingDocIdPusher.java b/test/com/google/enterprise/adaptor/fs/AccumulatingDocIdPusher.java
new file mode 100644
index 0000000..5c38e25
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/AccumulatingDocIdPusher.java
@@ -0,0 +1,96 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+//
+// 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 com.google.enterprise.adaptor.Acl;
+import com.google.enterprise.adaptor.DocId;
+import com.google.enterprise.adaptor.ExceptionHandler;
+import com.google.enterprise.adaptor.GroupPrincipal;
+import com.google.enterprise.adaptor.Principal;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+class AccumulatingDocIdPusher extends UnsupportedDocIdPusher {
+ private List<Record> records = new ArrayList<Record>();
+ private List<Map<DocId, Acl>> namedResouces
+ = new ArrayList<Map<DocId, Acl>>();
+
+ @Override
+ public DocId pushDocIds(Iterable<DocId> docIds)
+ throws InterruptedException {
+ return pushDocIds(docIds, null);
+ }
+
+ @Override
+ public DocId pushDocIds(Iterable<DocId> docIds,
+ ExceptionHandler handler)
+ throws InterruptedException {
+ List<Record> records = new ArrayList<Record>();
+ for (DocId docId : docIds) {
+ records.add(new Record.Builder(docId).build());
+ }
+ Record record = pushRecords(records, handler);
+ return record == null ? null : record.getDocId();
+ }
+
+ @Override
+ public Record pushRecords(Iterable<Record> records)
+ throws InterruptedException {
+ return pushRecords(records, null);
+ }
+
+ @Override
+ public Record pushRecords(Iterable<Record> records,
+ ExceptionHandler handler)
+ throws InterruptedException {
+ for (Record record : records) {
+ this.records.add(record);
+ }
+ return null;
+ }
+
+ @Override
+ public DocId pushNamedResources(Map<DocId, Acl> resources)
+ throws InterruptedException {
+ return pushNamedResources(resources, null);
+ }
+
+ @Override
+ public DocId pushNamedResources(Map<DocId, Acl> resources,
+ ExceptionHandler handler)
+ throws InterruptedException {
+ namedResouces.add(Collections.unmodifiableMap(
+ new TreeMap<DocId, Acl>(resources)));
+ return null;
+ }
+
+ public List<Record> getRecords() {
+ return Collections.unmodifiableList(records);
+ }
+
+ public List<Map<DocId, Acl>> getNamedResources() {
+ return Collections.unmodifiableList(namedResouces);
+ }
+
+ public void reset() {
+ records.clear();
+ namedResouces.clear();
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/FsAdaptorTest.java b/test/com/google/enterprise/adaptor/fs/FsAdaptorTest.java
index 9eb2d16..efb317c 100644
--- a/test/com/google/enterprise/adaptor/fs/FsAdaptorTest.java
+++ b/test/com/google/enterprise/adaptor/fs/FsAdaptorTest.java
@@ -1,4 +1,4 @@
-// Copyright 2013 Google Inc. All Rights Reserved.
+// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
@@ -14,38 +14,965 @@
package com.google.enterprise.adaptor.fs;
-import com.google.enterprise.adaptor.AccumulatingDocIdPusher;
+import static com.google.enterprise.adaptor.fs.AclView.user;
+import static com.google.enterprise.adaptor.fs.AclView.group;
+import static com.google.enterprise.adaptor.fs.AclView.GenericPermission.*;
import static org.junit.Assert.*;
+import static java.nio.file.attribute.AclEntryFlag.*;
+import static java.nio.file.attribute.AclEntryPermission.*;
+import static java.nio.file.attribute.AclEntryType.*;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Sets;
+import com.google.enterprise.adaptor.Acl;
+import com.google.enterprise.adaptor.Acl.InheritanceType;
+import com.google.enterprise.adaptor.AdaptorContext;
+import com.google.enterprise.adaptor.Config;
+import com.google.enterprise.adaptor.DocId;
+import com.google.enterprise.adaptor.DocIdPusher.Record;
+import com.google.enterprise.adaptor.GroupPrincipal;
+import com.google.enterprise.adaptor.UserPrincipal;
+
import org.junit.*;
import org.junit.rules.ExpectedException;
+import java.io.File;
+import java.io.FilterInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Path;
import java.nio.file.Paths;
+import java.nio.file.attribute.AclFileAttributeView;
+import java.nio.file.attribute.FileTime;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.BlockingQueue;
/** Test cases for {@link FsAdaptor}. */
public class FsAdaptorTest {
+
+ static final String ROOT = "/";
+ static final Path rootPath = Paths.get(ROOT);
+ static final DocId shareAclDocId = new DocId("shareAcl");
+
+ private final Set<String> windowsAccounts = ImmutableSet.of(
+ "BUILTIN\\Administrators", "Everyone", "BUILTIN\\Users",
+ "BUILTIN\\Guest", "NT AUTHORITY\\INTERACTIVE",
+ "NT AUTHORITY\\Authenticated Users");
+ private final String builtinPrefix = "BUILTIN\\";
+ private final String namespace = "Default";
+
+ private AdaptorContext context = new MockAdaptorContext();
+ private AccumulatingDocIdPusher pusher =
+ (AccumulatingDocIdPusher) context.getDocIdPusher();
+ private Config config = context.getConfig();
+ private MockFile root = new MockFile(ROOT, true);
+ private MockFileDelegate delegate = new MockFileDelegate(root);
+ private FsAdaptor adaptor = new FsAdaptor(delegate);
+ private DocId rootDocId;
+
+ @Before
+ public void setUp() throws Exception {
+ rootDocId = delegate.newDocId(rootPath);
+ adaptor.initConfig(config);
+ config.overrideKey("filesystemadaptor.src", root.getPath());
+ config.overrideKey("adaptor.incrementalPollPeriodSecs", "0");
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ adaptor.destroy();
+ }
+
@Rule
public ExpectedException thrown = ExpectedException.none();
+ private Path getPath(String path) {
+ return rootPath.resolve(path);
+ }
+
+ private DocId getDocId(String path) throws IOException {
+ return delegate.newDocId(getPath(path));
+ }
+
@Test
- public void testGetPathName() throws Exception {
- TestHelper.assumeOsIsWindows();
- FsAdaptor adaptor = new FsAdaptor();
- assertEquals("share", adaptor.getPathName(Paths.get("\\\\host/share/")));
- assertEquals("folder2",
- adaptor.getPathName(Paths.get("C:/folder1/folder2/")));
+ public void testAdaptorStartupShutdown() throws Exception {
+ // Construction of Adaptor happened in setUp(), and
+ // destruction will happen in tearDown(), so the only
+ // thing left is to init the context.
+ adaptor.init(context);
+ }
+
+ @Test
+ public void testAdaptorInitNoSourcePath() throws Exception {
+ config.overrideKey("filesystemadaptor.src", "");
+ thrown.expect(IOException.class);
+ adaptor.init(context);
+ }
+
+ @Test
+ public void testAdaptorInitNonRootSourcePath() throws Exception {
+ root.addChildren(new MockFile("subdir", true));
+ config.overrideKey("filesystemadaptor.src", getPath("subdir").toString());
+ thrown.expect(IllegalStateException.class);
+ adaptor.init(context);
+ }
+
+ @Test
+ public void testAdaptorInitDfsUncActiveStorageUnc() throws Exception {
+ root.setDfsUncActiveStorageUnc(Paths.get("\\\\dfshost\\share"));
+ adaptor.init(context);
+ }
+
+ @Test
+ public void testAdaptorInitNonLinkDfsUncActiveStorageUnc() throws Exception {
+ root.setDfsUncActiveStorageUnc(rootPath);
+ thrown.expect(IOException.class);
+ adaptor.init(context);
+ }
+
+ @Test
+ public void testAdaptorInitSupportedWindowsAccounts() throws Exception {
+ String accounts = "Everyone, BUILTIN\\Users, NT AUTH\\New Users";
+ Set<String> expected =
+ ImmutableSet.of("Everyone", "BUILTIN\\Users", "NT AUTH\\New Users");
+ config.overrideKey("filesystemadaptor.supportedAccounts", accounts);
+ adaptor.init(context);
+ assertEquals(expected, adaptor.getSupportedWindowsAccounts());
+ }
+
+ @Test
+ public void testAdaptorInitBuiltinGroupPrefix() throws Exception {
+ String expected = "TestPrefix";
+ config.overrideKey("filesystemadaptor.builtinGroupPrefix", expected);
+ adaptor.init(context);
+ assertEquals(expected, adaptor.getBuiltinPrefix());
+ }
+
+ @Test
+ public void testAdaptorInitNamespace() throws Exception {
+ String expected = "TestNamespace";
+ config.overrideKey("adaptor.namespace", expected);
+ adaptor.init(context);
+ assertEquals(expected, adaptor.getNamespace());
+ }
+
+ @Test
+ public void testGetFolderName() throws Exception {
+ assertEquals("share", adaptor.getFileName(Paths.get("\\\\host/share/")));
+ assertEquals("folder2",
+ adaptor.getFileName(Paths.get("C:/folder1/folder2/")));
+ assertEquals("folder2",
+ adaptor.getFileName(Paths.get("/folder1/folder2/")));
+ assertEquals("share", adaptor.getFileName(Paths.get("\\\\host/share")));
+ assertEquals("folder1",
+ adaptor.getFileName(Paths.get("/folder1")));
+ assertEquals(File.separator, // Windows flips the '/' to '\'.
+ adaptor.getFileName(Paths.get("/")));
+ assertEquals("C:\\",
+ adaptor.getFileName(Paths.get("C:\\")));
+ }
+
+ @Test
+ public void testIsSupportedPath() throws Exception {
+ root.addChildren(new MockFile("foo"), new MockFile("bar", true),
+ new MockFile("link").setIsRegularFile(false));
+ assertTrue(adaptor.isSupportedPath(rootPath));
+ assertTrue(adaptor.isSupportedPath(getPath("foo")));
+ assertTrue(adaptor.isSupportedPath(getPath("bar")));
+ assertFalse(adaptor.isSupportedPath(getPath("link")));
+ }
+
+ @Test
+ public void testIsVisibleDescendantOfRoot() throws Exception {
+ adaptor.init(context);
+ root.addChildren(new MockFile("foo"),
+ new MockFile("hidden.txt").setIsHidden(true),
+ new MockFile("dir1", true).addChildren(new MockFile("bar"),
+ new MockFile("hidden.pdf").setIsHidden(true)),
+ new MockFile("hidden.dir", true).setIsHidden(true).addChildren(
+ new MockFile("baz")));
+ assertTrue(adaptor.isVisibleDescendantOfRoot(rootPath));
+ assertTrue(adaptor.isVisibleDescendantOfRoot(getPath("foo")));
+ assertTrue(adaptor.isVisibleDescendantOfRoot(getPath("dir1")));
+ assertTrue(adaptor.isVisibleDescendantOfRoot(getPath("dir1/bar")));
+ assertFalse(adaptor.isVisibleDescendantOfRoot(getPath("hidden.txt")));
+ assertFalse(adaptor.isVisibleDescendantOfRoot(getPath("dir1/hidden.pdf")));
+ assertFalse(adaptor.isVisibleDescendantOfRoot(getPath("hidden.dir")));
+ assertFalse(adaptor.isVisibleDescendantOfRoot(getPath("hidden.dir/baz")));
+ assertFalse(adaptor.isVisibleDescendantOfRoot(null));
+ }
+
+ @Test
+ public void testGetDocIds() throws Exception {
+ adaptor.init(context);
+ adaptor.getDocIds(pusher);
+
+ // We should just push the root docid.
+ List<Record> records = pusher.getRecords();
+ assertEquals(1, records.size());
+ assertEquals(delegate.newDocId(rootPath), records.get(0).getDocId());
+
+ // We should have pushed an acl for the share.
+ List<Map<DocId, Acl>> namedResources = pusher.getNamedResources();
+ Acl expected = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitGroups(Collections.singleton(new GroupPrincipal("Everyone")))
+ .setInheritanceType(InheritanceType.AND_BOTH_PERMIT).build();
+ assertEquals(1, namedResources.size());
+ assertEquals(1, namedResources.get(0).size());
+ assertEquals(expected, namedResources.get(0).get(shareAclDocId));
+ }
+
+ @Test
+ public void testGetDocIdsDfs() throws Exception {
+ Path uncPath = Paths.get("\\\\dfshost\\share");
+ root.setDfsUncActiveStorageUnc(uncPath);
+ root.setDfsShareAclView(MockFile.FULL_ACCESS_ACLVIEW);
+ adaptor.init(context);
+ adaptor.getDocIds(pusher);
+
+ // We should just push the root docid.
+ List<Record> records = pusher.getRecords();
+ assertEquals(1, records.size());
+ assertEquals(delegate.newDocId(rootPath), records.get(0).getDocId());
+
+ // We should have pushed acls for the share and the dfsShare.
+ List<Map<DocId, Acl>> namedResources = pusher.getNamedResources();
+ DocId dfsShareAcl = new DocId("dfsShareAcl");
+ Acl expectedDfsShareAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitGroups(Collections.singleton(new GroupPrincipal("Everyone")))
+ .setInheritanceType(InheritanceType.AND_BOTH_PERMIT).build();
+ Acl expectedShareAcl = new Acl.Builder(expectedDfsShareAcl)
+ .setInheritFrom(dfsShareAcl).build();
+ assertEquals(1, namedResources.size());
+ Map<DocId, Acl> acls = namedResources.get(0);
+ assertEquals(2, acls.size());
+ assertEquals(expectedDfsShareAcl, acls.get(dfsShareAcl));
+ assertEquals(expectedShareAcl, acls.get(shareAclDocId));
+ }
+
+ @Test
+ public void testGetDocIdsBrokenDfs() throws Exception {
+ Path uncPath = Paths.get("\\\\dfshost\\share");
+ root.setDfsUncActiveStorageUnc(uncPath);
+ root.setDfsShareAclView(MockFile.FULL_ACCESS_ACLVIEW);
+ adaptor.init(context);
+
+ // Now make the active storage disappear.
+ root.setDfsUncActiveStorageUnc(null);
+ thrown.expect(IOException.class);
+ adaptor.getDocIds(pusher);
+ }
+
+ @Test
+ public void testGetDocContentUnsupportedPath() throws Exception {
+ root.addChildren(new MockFile("unsupported").setIsRegularFile(false));
+ adaptor.init(context);
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(new MockRequest(getDocId("unsupported")), response);
+ assertTrue(response.notFound);
+ }
+
+ /*
+ * This test was invalidated when the check for isSupportedPath()
+ * was moved above the check for bad DocIds in the beginning of
+ * FsAdaptor.getDocumentContent(). This test still passes, but
+ * the notFound response is coming from the earlier check for
+ * isSupportedPath(), not from the bad DocId.
+ */
+ @Test
+ public void testGetDocContentBadDocId() throws Exception {
+ root.addChildren(new MockFile("badfile"));
+ adaptor.init(context);
+ MockResponse response = new MockResponse();
+ // The requested DocId is missing the root component of the path.
+ adaptor.getDocContent(new MockRequest(new DocId("badfile")), response);
+ assertTrue(response.notFound);
+ }
+
+ @Test
+ public void testGetDocContentHiddenFile() throws Exception {
+ root.addChildren(new MockFile("hidden.txt").setIsHidden(true));
+ adaptor.init(context);
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(new MockRequest(getDocId("hidden.txt")), response);
+ assertTrue(response.notFound);
+ }
+
+ @Test
+ public void testGetDocContentHiddenDirectory() throws Exception {
+ root.addChildren(new MockFile("hidden.dir", true).setIsHidden(true));
+ adaptor.init(context);
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(new MockRequest(getDocId("hidden.dir")), response);
+ assertTrue(response.notFound);
+ }
+
+ @Test
+ public void testGetDocContentRegularFile() throws Exception {
+ String fname = "test.html";
+ Date modifyDate = new Date(30000);
+ FileTime modifyTime = FileTime.fromMillis(modifyDate.getTime());
+ String content = "<html><title>Hello World</title></html>";
+ root.addChildren(new MockFile(fname).setLastModifiedTime(modifyTime)
+ .setFileContents(content).setContentType("text/html"));
+ adaptor.init(context);
+
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(new MockRequest(getDocId(fname)), response);
+ assertFalse(response.notFound);
+ assertEquals(modifyDate, response.lastModified);
+ assertEquals(getPath(fname).toUri(), response.displayUrl);
+ assertEquals("text/html", response.contentType);
+ assertEquals(content, response.content.toString("UTF-8"));
+ // TODO: check metadata.
+ assertNotNull(response.metadata.get("Creation Time"));
+ // ACL checked in other tests.
+ }
+
+ @Test
+ public void testGetDocContentRootAcl() throws Exception {
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitGroups(Collections.singleton(new GroupPrincipal("Everyone")))
+ .setInheritFrom(shareAclDocId)
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES).build();
+ adaptor.init(context);
+ MockRequest request = new MockRequest(delegate.newDocId(rootPath));
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(request, response);
+ assertEquals(expectedAcl, response.acl);
+ }
+
+ @Test
+ public void testGetDocContentEmptyAcl() throws Exception {
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setInheritFrom(rootDocId, "childFilesAcl")
+ .setInheritanceType(InheritanceType.LEAF_NODE).build();
+ testFileAcl(MockFile.EMPTY_ACLVIEW, null, expectedAcl);
+ }
+
+ @Test
+ public void testGetDocContentDirectAcl() throws Exception {
+ AclFileAttributeView aclView = new AclView((user("joe")
+ .type(ALLOW).perms(GENERIC_READ).build()));
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(new UserPrincipal("joe")))
+ .setInheritFrom(rootDocId, "childFilesAcl")
+ .setInheritanceType(InheritanceType.LEAF_NODE).build();
+ testFileAcl(aclView, null, expectedAcl);
+ }
+
+ @Test
+ public void testGetDocContentNoInheritAcl() throws Exception {
+ AclFileAttributeView aclView = new AclView((user("joe")
+ .type(ALLOW).perms(GENERIC_READ).build()));
+ // Should inherit from the share, not the parent.
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(new UserPrincipal("joe")))
+ .setInheritFrom(shareAclDocId)
+ .setInheritanceType(InheritanceType.LEAF_NODE).build();
+ testFileAcl(aclView, MockFile.EMPTY_ACLVIEW, expectedAcl);
+ }
+
+ private void testFileAcl(AclFileAttributeView aclView,
+ AclFileAttributeView inheritAclView, Acl expectedAcl) throws Exception {
+ String fname = "acltest";
+ root.addChildren(new MockFile(fname).setAclView(aclView)
+ .setInheritedAclView(inheritAclView));
+ adaptor.init(context);
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(new MockRequest(getDocId(fname)), response);
+ assertEquals(expectedAcl, response.acl);
+ }
+
+ /** Test that LastAccessTime is restored after reading the file. */
+ @Test
+ public void testPreserveFileLastAccessTime() throws Exception {
+ testPreserveFileLastAccessTime(new MockFile("test") {
+ @Override
+ InputStream newInputStream() throws IOException {
+ setLastAccessTime(FileTime.fromMillis(
+ getLastAccessTime().toMillis() + 1000));
+ return super.newInputStream();
+ }
+ });
+ }
+
+ /** Test LastAccessTime is restored even if exception opening the file. */
+ @Test
+ public void testPreserveFileLastAccessTimeException1() throws Exception {
+ thrown.expect(IOException.class);
+ testPreserveFileLastAccessTime(new MockFile("test") {
+ @Override
+ InputStream newInputStream() throws IOException {
+ setLastAccessTime(FileTime.fromMillis(
+ getLastAccessTime().toMillis() + 1000));
+ throw new IOException("newInputStream");
+ }
+ });
+ }
+
+ /** Test LastAccessTime is restored even if exception reading the file. */
+ @Test
+ public void testPreserveFileLastAccessTimeException2() throws Exception {
+ thrown.expect(IOException.class);
+ testPreserveFileLastAccessTime(new MockFile("test") {
+ @Override
+ InputStream newInputStream() throws IOException {
+ setLastAccessTime(FileTime.fromMillis(
+ getLastAccessTime().toMillis() + 1000));
+ return new FilterInputStream(super.newInputStream()) {
+ @Override
+ public int read(byte[] b, int off, int len) throws IOException {
+ throw new IOException("read");
+ }
+ };
+ }
+ });
+ }
+
+ /** Test LastAccessTime is restored even if exception closing the file. */
+ @Test
+ public void testPreserveFileLastAccessTimeException3() throws Exception {
+ thrown.expect(IOException.class);
+ testPreserveFileLastAccessTime(new MockFile("test") {
+ @Override
+ InputStream newInputStream() throws IOException {
+ setLastAccessTime(FileTime.fromMillis(
+ getLastAccessTime().toMillis() + 1000));
+ return new FilterInputStream(super.newInputStream()) {
+ @Override
+ public void close() throws IOException {
+ throw new IOException("close");
+ }
+ };
+ }
+ });
+ }
+
+ /** Test that failure to restore LastAccessTime is not fatal. */
+ @Test
+ public void testPreserveFileLastAccessTimeException4() throws Exception {
+ testNoPreserveFileLastAccessTime(new MockFile("test") {
+ @Override
+ InputStream newInputStream() throws IOException {
+ setLastAccessTime(FileTime.fromMillis(
+ getLastAccessTime().toMillis() + 1000));
+ return super.newInputStream();
+ }
+ @Override
+ MockFile setLastAccessTime(FileTime accessTime) throws IOException {
+ if (MockFile.DEFAULT_FILETIME.equals(getLastAccessTime())) {
+ // Let the above setting from newInputStream go through.
+ return super.setLastAccessTime(accessTime);
+ } else {
+ // But fail the attempt to restore from FsAdaptor.
+ throw new IOException("Restore LastAccessTime");
+ }
+ }
+ });
+ }
+
+ private void testPreserveFileLastAccessTime(MockFile file) throws Exception {
+ testFileLastAccessTime(file, true);
+ }
+
+ private void testNoPreserveFileLastAccessTime(MockFile file)
+ throws Exception {
+ testFileLastAccessTime(file, false);
+ }
+
+ private void testFileLastAccessTime(MockFile file, boolean isPreserved)
+ throws Exception {
+ String contents = "Test contents";
+ file.setFileContents(contents);
+ root.addChildren(file);
+ adaptor.init(context);
+ MockResponse response = new MockResponse();
+ FileTime lastAccess = file.getLastAccessTime();
+ adaptor.getDocContent(new MockRequest(getDocId(file.getName())), response);
+ // Verify we indeed accessed the file
+ assertEquals(contents, response.content.toString("UTF-8"));
+ if (isPreserved) {
+ assertEquals(lastAccess, file.getLastAccessTime());
+ } else {
+ assertFalse(lastAccess.equals(file.getLastAccessTime()));
+ }
+ }
+
+ @Test
+ public void testGetDocContentRoot() throws Exception {
+ testGetDocContentDirectory(rootPath, rootPath.toString());
+ // ACLs checked in other tests.
+ }
+
+ @Test
+ public void testGetDocContentDirectory() throws Exception {
+ String fname = "test.dir";
+ root.addChildren(new MockFile(fname, true));
+ testGetDocContentDirectory(getPath(fname), fname);
+ // ACLs checked in other tests.
+ }
+
+ private void testGetDocContentDirectory(Path path, String label)
+ throws Exception {
+ MockFile dir = delegate.getFile(path);
+ FileTime modifyTime = dir.getLastModifiedTime();
+ Date modifyDate = new Date(modifyTime.toMillis());
+ dir.addChildren(new MockFile("test.txt"), new MockFile("subdir", true));
+ adaptor.init(context);
+ MockRequest request = new MockRequest(delegate.newDocId(path));
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(request, response);
+ assertFalse(response.notFound);
+ assertEquals(modifyDate, response.lastModified);
+ assertEquals(path.toUri(), response.displayUrl);
+ assertEquals("text/html; charset=UTF-8", response.contentType);
+ String expectedContent = "<!DOCTYPE html>\n<html><head><title>Folder "
+ + label + "</title></head><body><h1>Folder " + label + "</h1>"
+ + "<li><a href=\"subdir/\">subdir</a></li>"
+ + "<li><a href=\"test.txt\">test.txt</a></li></body></html>";
+ assertEquals(expectedContent, response.content.toString("UTF-8"));
+ assertNotNull(response.metadata.get("Creation Time"));
+ }
+
+ @Test
+ public void testGetDocContentDefaultRootAcls() throws Exception {
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitGroups(Collections.singleton(new GroupPrincipal("Everyone")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(shareAclDocId).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedAcl,
+ "allFilesAcl", expectedAcl,
+ "childFoldersAcl", expectedAcl,
+ "childFilesAcl", expectedAcl);
+ testGetDocContentAcls(rootPath, expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentInheritOnlyRootAcls() throws Exception {
+ AclFileAttributeView inheritOnlyAclView = new AclView(
+ user("Longfellow Deeds").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT, INHERIT_ONLY),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.setAclView(inheritOnlyAclView);
+
+ // The root ACL should only include Administrators, not Mr. Deeds.
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(shareAclDocId).build();
+ // But the childrens' inherited ACLs should include Mr. Deeds
+ Acl expectedInheritableAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("Longfellow Deeds")))
+ .build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedInheritableAcl,
+ "allFilesAcl", expectedInheritableAcl,
+ "childFoldersAcl", expectedInheritableAcl,
+ "childFilesAcl", expectedInheritableAcl);
+ testGetDocContentAcls(rootPath, expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentNoPropagateRootAcls() throws Exception {
+ AclFileAttributeView noPropagateAclView = new AclView(
+ user("Barren von Dink").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT, NO_PROPAGATE_INHERIT),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.setAclView(noPropagateAclView);
+
+ // The root ACL should include both Administrators and the Barren.
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("Barren von Dink")))
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(shareAclDocId).build();
+ // The direct childrens' inherited ACLs should include both the
+ // Administrators and the Barren, but grandchildren should not
+ // inherit the Barren's NO_PROPAGATE permission.
+ Acl expectedNonChildAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.<UserPrincipal>emptySet()).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedNonChildAcl,
+ "allFilesAcl", expectedNonChildAcl,
+ "childFoldersAcl", expectedAcl,
+ "childFilesAcl", expectedAcl);
+ testGetDocContentAcls(rootPath, expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentFilesOnlyRootAcls() throws Exception {
+ AclFileAttributeView noPropagateAclView = new AclView(
+ user("For Your Files Only").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.setAclView(noPropagateAclView);
+
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("For Your Files Only")))
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(shareAclDocId).build();
+ // Folders shouldn't include the file-only permissions.
+ Acl expectedFolderAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.<UserPrincipal>emptySet()).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedFolderAcl,
+ "allFilesAcl", expectedAcl,
+ "childFoldersAcl", expectedFolderAcl,
+ "childFilesAcl", expectedAcl);
+ testGetDocContentAcls(rootPath, expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentFoldersOnlyRootAcls() throws Exception {
+ AclFileAttributeView noPropagateAclView = new AclView(
+ user("Fluff 'n Folder").type(ALLOW).perms(GENERIC_READ)
+ .flags(DIRECTORY_INHERIT),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.setAclView(noPropagateAclView);
+
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("Fluff 'n Folder")))
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(shareAclDocId).build();
+ // Files shouldn't include the folder-only permissions.
+ Acl expectedFilesAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.<UserPrincipal>emptySet()).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedAcl,
+ "allFilesAcl", expectedFilesAcl,
+ "childFoldersAcl", expectedAcl,
+ "childFilesAcl", expectedFilesAcl);
+ testGetDocContentAcls(rootPath, expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentDefaultDirectoryAcls() throws Exception {
+ String name = "subdir";
+ root.addChildren(new MockFile(name, true));
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(rootDocId, "childFoldersAcl").build();
+ Acl expectedFoldersAcl = new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFoldersAcl").build();
+ Acl expectedFilesAcl = new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedFoldersAcl,
+ "allFilesAcl", expectedFilesAcl,
+ "childFoldersAcl", expectedFoldersAcl,
+ "childFilesAcl", expectedFilesAcl);
+ testGetDocContentAcls(getPath(name), expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentNoInheritDirectoryAcls() throws Exception {
+ String name = "subdir";
+ AclFileAttributeView orphanAclView = new AclView(user("Annie").type(ALLOW)
+ .perms(GENERIC_READ).flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.addChildren(new MockFile(name, true).setAclView(orphanAclView)
+ .setInheritedAclView(MockFile.EMPTY_ACLVIEW));
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(new UserPrincipal("Annie")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(shareAclDocId).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedAcl,
+ "allFilesAcl", expectedAcl,
+ "childFoldersAcl", expectedAcl,
+ "childFilesAcl", expectedAcl);
+ testGetDocContentAcls(getPath(name), expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentInheritOnlyDirectoryAcls() throws Exception {
+ String name = "subdir";
+ AclFileAttributeView inheritOnlyAclView = new AclView(
+ user("Longfellow Deeds").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT, INHERIT_ONLY),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.addChildren(new MockFile(name, true).setAclView(inheritOnlyAclView));
+
+ // The root ACL should only include Administrators, not Mr. Deeds.
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(rootDocId, "childFoldersAcl").build();
+ // But the childrens' inherited ACLs should include Mr. Deeds
+ Acl expectedFoldersAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("Longfellow Deeds")))
+ .setInheritFrom(rootDocId, "allFoldersAcl").build();
+ Acl expectedFilesAcl = new Acl.Builder(expectedFoldersAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", expectedFoldersAcl,
+ "allFilesAcl", expectedFilesAcl,
+ "childFoldersAcl", expectedFoldersAcl,
+ "childFilesAcl", expectedFilesAcl);
+ testGetDocContentAcls(getPath(name), expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentNoPropagateDirectoryAcls() throws Exception {
+ String name = "subdir";
+ AclFileAttributeView noPropagateAclView = new AclView(
+ user("Barren von Dink").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT, NO_PROPAGATE_INHERIT),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.addChildren(new MockFile(name, true).setAclView(noPropagateAclView));
+
+ // The root ACL should include both Administrators and the Barren.
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("Barren von Dink")))
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(rootDocId, "childFoldersAcl").build();
+ // The direct childrens' inherited ACLs should include both the
+ // Administrators and the Barren, but grandchildren should not
+ // inherit the Barren's NO_PROPAGATE permission.
+ Acl expectedNonChildAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.<UserPrincipal>emptySet()).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", new Acl.Builder(expectedNonChildAcl)
+ .setInheritFrom(rootDocId, "allFoldersAcl").build(),
+ "allFilesAcl", new Acl.Builder(expectedNonChildAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build(),
+ "childFoldersAcl", new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFoldersAcl").build(),
+ "childFilesAcl", new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build());
+ testGetDocContentAcls(getPath(name), expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentFilesOnlyDirectoryAcls() throws Exception {
+ String name = "subdir";
+ AclFileAttributeView filesOnlyAclView = new AclView(
+ user("For Your Files Only").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.addChildren(new MockFile(name, true).setAclView(filesOnlyAclView));
+
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("For Your Files Only")))
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(rootDocId, "childFoldersAcl").build();
+ // Folders shouldn't include the file-only permissions.
+ Acl expectedFolderAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.<UserPrincipal>emptySet()).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", new Acl.Builder(expectedFolderAcl)
+ .setInheritFrom(rootDocId, "allFoldersAcl").build(),
+ "allFilesAcl", new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build(),
+ "childFoldersAcl", new Acl.Builder(expectedFolderAcl)
+ .setInheritFrom(rootDocId, "allFoldersAcl").build(),
+ "childFilesAcl", new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build());
+ testGetDocContentAcls(getPath(name), expectedAcl, expectedResources);
+ }
+
+ @Test
+ public void testGetDocContentFoldersOnlyDirectoryAcls() throws Exception {
+ String name = "subdir";
+ AclFileAttributeView foldersOnlyAclView = new AclView(
+ user("Fluff 'n Folder").type(ALLOW).perms(GENERIC_READ)
+ .flags(DIRECTORY_INHERIT),
+ group("Administrators").type(ALLOW).perms(GENERIC_ALL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ root.addChildren(new MockFile(name, true).setAclView(foldersOnlyAclView));
+
+ Acl expectedAcl = new Acl.Builder().setEverythingCaseInsensitive()
+ .setPermitUsers(Collections.singleton(
+ new UserPrincipal("Fluff 'n Folder")))
+ .setPermitGroups(Collections.singleton(
+ new GroupPrincipal("Administrators")))
+ .setInheritanceType(InheritanceType.CHILD_OVERRIDES)
+ .setInheritFrom(rootDocId, "childFoldersAcl").build();
+ // Files shouldn't include the folder-only permissions.
+ Acl expectedFilesAcl = new Acl.Builder(expectedAcl)
+ .setPermitUsers(Collections.<UserPrincipal>emptySet()).build();
+ Map<String, Acl> expectedResources = ImmutableMap.of(
+ "allFoldersAcl", new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFoldersAcl").build(),
+ "allFilesAcl", new Acl.Builder(expectedFilesAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build(),
+ "childFoldersAcl", new Acl.Builder(expectedAcl)
+ .setInheritFrom(rootDocId, "allFoldersAcl").build(),
+ "childFilesAcl", new Acl.Builder(expectedFilesAcl)
+ .setInheritFrom(rootDocId, "allFilesAcl").build());
+ testGetDocContentAcls(getPath(name), expectedAcl, expectedResources);
+ }
+
+ private void testGetDocContentAcls(Path path, Acl expectedAcl,
+ Map<String, Acl> expectedAclResources) throws Exception {
+ adaptor.init(context);
+ MockRequest request = new MockRequest(delegate.newDocId(path));
+ MockResponse response = new MockResponse();
+ adaptor.getDocContent(request, response);
+ assertEquals(expectedAcl, response.acl);
+ assertEquals(expectedAclResources, response.namedResources);
+ }
+
+ @Test
+ public void testMonitorZeroFeedSize() throws Exception {
+ config.overrideKey("feed.maxUrls", "0");
+ thrown.expect(IllegalArgumentException.class);
+ adaptor.init(context);
+ }
+
+ @Test
+ public void testMonitorZeroLatency() throws Exception {
+ config.overrideKey("adaptor.incrementalPollPeriodSecs", "0");
+ adaptor.init(context);
+ }
+
+
+ @Test
+ public void testMonitorSubZeroLatency() throws Exception {
+ config.overrideKey("adaptor.incrementalPollPeriodSecs", "-1");
+ thrown.expect(IllegalArgumentException.class);
+ adaptor.init(context);
+ }
+
+ @Test
+ public void testMonitorUnsupportedPath() throws Exception {
+ root.addChildren(new MockFile("unsuppored").setIsRegularFile(false));
+ adaptor.init(context);
+ BlockingQueue<Path> queue = adaptor.getFsMonitorQueue();
+ queue.add(getPath("unsupported"));
+ Thread.sleep(100L); // Allow FsMonitor to drain the queue.
+ // Verify it has been processed, but not been fed.
+ assertEquals(0, queue.size());
+ assertEquals(0, pusher.getRecords().size());
+ assertEquals(0, pusher.getNamedResources().size());
+ }
+
+ @Test
+ public void testMonitorOneFile() throws Exception {
+ String name = "test";
+ root.addChildren(new MockFile(name));
+ adaptor.init(context);
+ testMonitor(name);
+ }
+
+ @Test
+ public void testMonitorOneDirectory() throws Exception {
+ String name = "test.dir";
+ root.addChildren(new MockFile(name, true));
+ adaptor.init(context);
+ testMonitor(name);
+ }
+
+ @Test
+ public void testMonitorMultipleItems() throws Exception {
+ String dirname = "subdir";
+ String fname = "test.txt";
+ root.addChildren(new MockFile(dirname, true), new MockFile(fname));
+ adaptor.init(context);
+ testMonitor(dirname, fname);
+ }
+
+ @Test
+ public void testMonitorMultipleBatches() throws Exception {
+ String dirname = "subdir";
+ String fname = "test.txt";
+ root.addChildren(new MockFile(dirname, true), new MockFile(fname));
+ adaptor.init(context);
+ testMonitor(dirname);
+ // Make sure the previous batch does not get fed again.
+ pusher.reset();
+ testMonitor(fname);
+ }
+
+ private void testMonitor(String... names) throws Exception {
+ BlockingQueue<Path> queue = adaptor.getFsMonitorQueue();
+ for (String name : names) {
+ queue.add(getPath(name));
+ }
+ Thread.sleep(100L); // Allow FsMonitor to drain the queue.
+ assertEquals(0, queue.size());
+ assertEquals(0, pusher.getNamedResources().size());
+ Set<Record> expected = Sets.newHashSet();
+ for (String name : names) {
+ expected.add(new Record.Builder(getDocId(name))
+ .setCrawlImmediately(true).build());
+ }
+ assertEquals(expected, Sets.newHashSet(pusher.getRecords()));
}
@Test
public void testIncrementalShareAcls() throws Exception {
- FsAdaptor adaptor = new FsAdaptor();
- AccumulatingDocIdPusher pusher = new AccumulatingDocIdPusher();
+ adaptor.init(context);
+
+ AclFileAttributeView aclView = new AclView(
+ user("joe").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ Acl acl =
+ newBuilder(aclView).getAcl().setInheritanceType(
+ InheritanceType.AND_BOTH_PERMIT).build();
+ root.setShareAclView(aclView);
+
adaptor.getDocIds(pusher);
+ List<Map<DocId, Acl>> namedResources = pusher.getNamedResources();
+ assertEquals(1, namedResources.size());
+ assertEquals(acl, namedResources.get(0).get(shareAclDocId));
+
+ // Clear the pusher and call getModifiedDocIds. Nothing should be
+ // pushed since the share Acl has not changed.
+ pusher.reset();
+ adaptor.getModifiedDocIds(pusher);
+ namedResources = pusher.getNamedResources();
+ assertEquals(0, namedResources.size());
+
+ // Change the share Acl and confirm that that the share Acl is pushed.
+ aclView = new AclView(user("mary").type(ALLOW).perms(GENERIC_READ)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ acl = newBuilder(aclView).getAcl().setInheritanceType(
+ InheritanceType.AND_BOTH_PERMIT).build();
+ root.setShareAclView(aclView);
adaptor.getModifiedDocIds(pusher);
- assertEquals("share", adaptor.getPathName(Paths.get("\\\\host/share/")));
- assertEquals("folder2",
- adaptor.getPathName(Paths.get("C:/folder1/folder2/")));
+ namedResources = pusher.getNamedResources();
+ assertEquals(1, namedResources.size());
+ assertEquals(acl, namedResources.get(0).get(shareAclDocId));
+ }
+
+ /** Returns an AclBuilder for the AclFileAttributeView. */
+ private AclBuilder newBuilder(AclFileAttributeView aclView) {
+ return new AclBuilder(Paths.get("foo", "bar"),
+ aclView, windowsAccounts, builtinPrefix, namespace);
}
}
diff --git a/test/com/google/enterprise/adaptor/fs/MockAdaptorContext.java b/test/com/google/enterprise/adaptor/fs/MockAdaptorContext.java
new file mode 100644
index 0000000..5749306
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockAdaptorContext.java
@@ -0,0 +1,110 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 com.google.enterprise.adaptor.AdaptorContext;
+import com.google.enterprise.adaptor.AuthnAuthority;
+import com.google.enterprise.adaptor.AuthzAuthority;
+import com.google.enterprise.adaptor.Config;
+import com.google.enterprise.adaptor.DocIdEncoder;
+import com.google.enterprise.adaptor.DocIdPusher;
+import com.google.enterprise.adaptor.ExceptionHandler;
+import com.google.enterprise.adaptor.PollingIncrementalLister;
+import com.google.enterprise.adaptor.SensitiveValueDecoder;
+import com.google.enterprise.adaptor.Session;
+import com.google.enterprise.adaptor.StatusSource;
+
+import com.sun.net.httpserver.HttpContext;
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+
+/**
+ * Mock of {@link AdaptorContext}.
+ */
+class MockAdaptorContext implements AdaptorContext {
+ private final Config config = new Config();
+ private final DocIdPusher docIdPusher = new AccumulatingDocIdPusher();
+ private final DocIdEncoder docIdEncoder = new MockDocIdCodec();
+
+ @Override
+ public Config getConfig() {
+ return config;
+ }
+
+ @Override
+ public DocIdPusher getDocIdPusher() {
+ return docIdPusher;
+ }
+
+ @Override
+ public DocIdEncoder getDocIdEncoder() {
+ return docIdEncoder;
+ }
+
+ @Override
+ public void addStatusSource(StatusSource source) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setGetDocIdsFullErrorHandler(ExceptionHandler handler) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ExceptionHandler getGetDocIdsFullErrorHandler() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setGetDocIdsIncrementalErrorHandler(
+ ExceptionHandler handler) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public ExceptionHandler getGetDocIdsIncrementalErrorHandler() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public SensitiveValueDecoder getSensitiveValueDecoder() {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public HttpContext createHttpContext(String path, HttpHandler handler) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Session getUserSession(HttpExchange ex, boolean create) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setPollingIncrementalLister(PollingIncrementalLister lister) {
+ }
+
+ @Override
+ public void setAuthnAuthority(AuthnAuthority authnAuthority) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setAuthzAuthority(AuthzAuthority authzAuthority) {
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/MockDocIdCodec.java b/test/com/google/enterprise/adaptor/fs/MockDocIdCodec.java
new file mode 100644
index 0000000..e669083
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockDocIdCodec.java
@@ -0,0 +1,37 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+//
+// 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 com.google.enterprise.adaptor.DocId;
+import com.google.enterprise.adaptor.DocIdEncoder;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+/**
+ * Mock of {@link DocIdCodec}.
+ */
+class MockDocIdCodec implements DocIdEncoder {
+ @Override
+ public URI encodeDocId(DocId docId) {
+ try {
+ String id = docId.getUniqueId();
+ return new URI("http", "localhost",
+ id.startsWith("/") ? id : "/" + id, null);
+ } catch (URISyntaxException ex) {
+ throw new AssertionError();
+ }
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/MockFile.java b/test/com/google/enterprise/adaptor/fs/MockFile.java
new file mode 100644
index 0000000..eb97926
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockFile.java
@@ -0,0 +1,399 @@
+// Copyright 2009 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 com.google.enterprise.adaptor.fs.AclView.user;
+import static com.google.enterprise.adaptor.fs.AclView.group;
+
+import static java.nio.file.attribute.AclEntryFlag.*;
+import static java.nio.file.attribute.AclEntryPermission.*;
+import static java.nio.file.attribute.AclEntryType.*;
+
+import com.google.common.base.Charsets;
+import com.google.common.base.Preconditions;
+
+import java.io.ByteArrayInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.attribute.AclFileAttributeView;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileTime;
+import java.nio.file.DirectoryStream;
+import java.nio.file.NotDirectoryException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+class MockFile {
+ static final String SEPARATOR = "/";
+ static final FileTime DEFAULT_FILETIME = FileTime.fromMillis(10000);
+ static final AclFileAttributeView FULL_ACCESS_ACLVIEW =
+ new AclView(group("Everyone").type(ALLOW)
+ .perms(READ_DATA, READ_ATTRIBUTES, READ_NAMED_ATTRS, READ_ACL)
+ .flags(FILE_INHERIT, DIRECTORY_INHERIT));
+ static final AclFileAttributeView EMPTY_ACLVIEW = new AclView();
+
+ private MockFile parent;
+ private String name;
+ private boolean isHidden = false;
+ private boolean isRegularFile;
+ private boolean isDirectory;
+ private List<MockFile> directoryContents;
+ private Path dfsUncActiveStorageUnc;
+ private AclFileAttributeView dfsShareAclView;
+ private AclFileAttributeView shareAclView;
+ private AclFileAttributeView aclView;
+ private AclFileAttributeView inheritedAclView;
+ private FileTime creationTime = DEFAULT_FILETIME;
+ private FileTime lastModifiedTime = DEFAULT_FILETIME;
+ private FileTime lastAccessTime = DEFAULT_FILETIME;
+ private String contentType;
+ private byte[] fileContents;
+
+ /**
+ * Create a regular file with the specified {@code name}.
+ *
+ * @param name the name of the file
+ */
+ MockFile(String name) {
+ this(name, false);
+ }
+
+ /**
+ * Create a file or directory with the specified {@code name}.
+ *
+ * @param name the name of the file or directory
+ * @param isDirectory true if this is a directory, false if regular file
+ */
+ MockFile(String name, boolean isDirectory) {
+ Preconditions.checkNotNull(name, "name cannot be null");
+ this.name = name;
+ this.isRegularFile = !isDirectory;
+ this.isDirectory = isDirectory;
+ if (isDirectory) {
+ directoryContents = new ArrayList<MockFile>();
+ } else {
+ setFileContents("Contents of " + name);
+ }
+ }
+
+ /**
+ * Add the supplied files/directories as children of this MockFile.
+ * This automatically sets isDirectory and resets isRegularFile on this
+ * MockFile, and registers this file as the parent of all the children.
+ */
+ MockFile addChildren(MockFile... children) {
+ Preconditions.checkState(isDirectory, "not a directory %s", getPath());
+ for (MockFile child : children) {
+ child.parent = this;
+ directoryContents.add(child);
+ }
+ return this;
+ }
+
+ /**
+ * Returns the child of the given name.
+ */
+ MockFile getChild(String name) throws FileNotFoundException {
+ Preconditions.checkNotNull(name, "name cannot be null");
+ Preconditions.checkState(isDirectory, "not a directory %s", getPath());
+ Iterator<MockFile> it = directoryContents.iterator();
+ while (it.hasNext()) {
+ MockFile f = it.next();
+ if (f.name.equals(name)) {
+ return f;
+ }
+ }
+ throw new FileNotFoundException(
+ "no such file: " + getPath() + SEPARATOR + name);
+ }
+
+ /**
+ * Return the path to this file or directory.
+ */
+ String getPath() {
+ if (parent == null) {
+ return name;
+ } else {
+ String parentPath = parent.getPath();
+ return (parentPath.endsWith(SEPARATOR))
+ ? parentPath + name : parentPath + SEPARATOR + name;
+ }
+ }
+
+ MockFile setName(String name) {
+ Preconditions.checkNotNull(name, "name cannot be null");
+ this.name = name;
+ return this;
+ }
+
+ /**
+ * Return the name to this file or directory.
+ */
+ String getName() {
+ return name;
+ }
+
+ /**
+ * Return the parent directory of this file or directory,
+ * or null if there is no parent.
+ */
+ MockFile getParent() {
+ return parent;
+ }
+
+ boolean isDirectory() throws IOException {
+ return isDirectory;
+ }
+
+ /** If false, maybe a directory, pipe, device, broken link, hidden, etc. */
+ MockFile setIsRegularFile(boolean isRegularFile) {
+ this.isRegularFile = isRegularFile;
+ return this;
+ }
+
+ boolean isRegularFile() throws IOException {
+ return isRegularFile;
+ }
+
+ MockFile setIsHidden(boolean isHidden) {
+ this.isHidden = isHidden;
+ return this;
+ }
+
+ boolean isHidden() throws IOException {
+ return isHidden;
+ }
+
+ MockFile setCreationTime(FileTime creationTime) {
+ Preconditions.checkNotNull(creationTime, "time cannot be null");
+ this.creationTime = creationTime;
+ return this;
+ }
+
+ FileTime getCreationTime() throws IOException {
+ return creationTime;
+ }
+
+ MockFile setLastModifiedTime(FileTime lastModifiedTime) {
+ Preconditions.checkNotNull(lastModifiedTime, "time cannot be null");
+ this.lastModifiedTime = lastModifiedTime;
+ return this;
+ }
+
+ FileTime getLastModifiedTime() throws IOException {
+ return lastModifiedTime;
+ }
+
+ /** Note that the adaptor calls this setter. */
+ MockFile setLastAccessTime(FileTime lastAccessTime) throws IOException {
+ Preconditions.checkNotNull(lastAccessTime, "time cannot be null");
+ this.lastAccessTime = lastAccessTime;
+ return this;
+ }
+
+ FileTime getLastAccessTime() throws IOException {
+ return lastAccessTime;
+ }
+
+ BasicFileAttributes readBasicAttributes() throws IOException {
+ return new MockBasicFileAttributes();
+ }
+
+ MockFile setDfsUncActiveStorageUnc(Path unc) {
+ this.dfsUncActiveStorageUnc = unc;
+ return this;
+ }
+
+ Path getDfsUncActiveStorageUnc() throws IOException {
+ return dfsUncActiveStorageUnc;
+ }
+
+ MockFile setDfsShareAclView(AclFileAttributeView aclView) {
+ this.dfsShareAclView = aclView;
+ return this;
+ }
+
+ AclFileAttributeView getDfsShareAclView() throws IOException {
+ return dfsShareAclView;
+ }
+
+ MockFile setShareAclView(AclFileAttributeView aclView) {
+ this.shareAclView = aclView;
+ return this;
+ }
+
+ AclFileAttributeView getShareAclView() throws IOException {
+ return (shareAclView == null) ? FULL_ACCESS_ACLVIEW : shareAclView;
+ }
+
+ MockFile setAclView(AclFileAttributeView aclView) {
+ this.aclView = aclView;
+ return this;
+ }
+
+ AclFileAttributeView getAclView() throws IOException {
+ if (aclView == null) {
+ return (parent == null) ? FULL_ACCESS_ACLVIEW : EMPTY_ACLVIEW;
+ } else {
+ return aclView;
+ }
+ }
+
+ MockFile setInheritedAclView(AclFileAttributeView aclView) {
+ this.inheritedAclView = aclView;
+ return this;
+ }
+
+ AclFileAttributeView getInheritedAclView() throws IOException {
+ if (inheritedAclView == null) {
+ if (parent == null) {
+ // root has no inherited ACL
+ return EMPTY_ACLVIEW;
+ } else if (parent.parent == null) {
+ // root's children inherit its ACL
+ return parent.getAclView();
+ } else {
+ // all other children inherit from their parent
+ return parent.getInheritedAclView();
+ }
+ } else {
+ return inheritedAclView;
+ }
+ }
+
+ MockFile setContentType(String contentType) {
+ this.contentType = contentType;
+ return this;
+ }
+
+ String getContentType() throws IOException {
+ return isRegularFile ? contentType : null;
+ }
+
+ MockFile setFileContents(String fileContents) {
+ Preconditions.checkNotNull(fileContents, "fileContents cannot be null");
+ setFileContents(fileContents.getBytes(Charsets.UTF_8));
+ if (contentType == null) {
+ contentType = "text/plain";
+ }
+ return this;
+ }
+
+ MockFile setFileContents(byte[] fileContents) {
+ Preconditions.checkState(isRegularFile, "not a regular file %s", getPath());
+ Preconditions.checkNotNull(fileContents, "fileContents cannot be null");
+ this.fileContents = fileContents;
+ return this;
+ }
+
+ InputStream newInputStream() throws IOException {
+ Preconditions.checkState(isRegularFile, "not a regular file %s", getPath());
+ return new ByteArrayInputStream(fileContents);
+ }
+
+ DirectoryStream<Path> newDirectoryStream() throws IOException {
+ if (!isDirectory) {
+ throw new NotDirectoryException("not a directory " + getPath());
+ }
+ return new MockDirectoryStream(directoryContents);
+ }
+
+ @Override
+ public String toString() {
+ return getPath();
+ }
+
+ private class MockBasicFileAttributes implements BasicFileAttributes {
+
+ @Override
+ public Object fileKey() {
+ return MockFile.this;
+ }
+
+ @Override
+ public FileTime creationTime() {
+ return creationTime;
+ }
+
+ @Override
+ public FileTime lastAccessTime() {
+ return lastAccessTime;
+ }
+
+ @Override
+ public FileTime lastModifiedTime() {
+ return lastModifiedTime;
+ }
+
+ @Override
+ public boolean isDirectory() {
+ return isDirectory;
+ }
+
+ @Override
+ public boolean isRegularFile() {
+ return isRegularFile;
+ }
+
+ @Override
+ public boolean isOther() {
+ return !(isDirectory || isRegularFile);
+ }
+
+ @Override
+ public boolean isSymbolicLink() {
+ return false;
+ }
+
+ @Override
+ public long size() {
+ if (isRegularFile && fileContents != null) {
+ return fileContents.length;
+ } else {
+ return 0L;
+ }
+ }
+ }
+
+ private class MockDirectoryStream implements DirectoryStream<Path> {
+ private Iterator<Path> iterator;
+
+ MockDirectoryStream(List<MockFile> files) {
+ ArrayList<Path> paths = new ArrayList<Path>();
+ for (MockFile file : files) {
+ paths.add(Paths.get(file.getPath()));
+ }
+ Collections.sort(paths);
+ iterator = paths.iterator();
+ }
+
+ @Override
+ public Iterator<Path> iterator() {
+ Preconditions.checkState(iterator != null,
+ "multiple attempts to get iterator");
+ Iterator<Path> rtn = iterator;
+ iterator = null;
+ return rtn;
+ }
+
+ @Override
+ public void close() {}
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/MockFileDelegate.java b/test/com/google/enterprise/adaptor/fs/MockFileDelegate.java
new file mode 100644
index 0000000..9a4c6f8
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockFileDelegate.java
@@ -0,0 +1,178 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// 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 com.google.common.base.Preconditions;
+import com.google.enterprise.adaptor.DocId;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.attribute.AclFileAttributeView;
+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.concurrent.BlockingQueue;
+import java.util.Iterator;
+
+class MockFileDelegate implements FileDelegate {
+
+ private final MockFile root;
+
+ MockFileDelegate(MockFile root) {
+ Preconditions.checkNotNull(root, "root cannot be null");
+ this.root = root;
+ }
+
+ /**
+ * Returns the {@link MockFile} identified by the supplied {@link Path}.
+ * @throws FileNotFoundException if the file is not found.
+ */
+ MockFile getFile(Path doc) throws FileNotFoundException {
+ Preconditions.checkNotNull(doc, "doc cannot be null");
+ MockFile file = root;
+ Iterator<Path> iter = doc.iterator();
+ if (doc.getRoot() != null) {
+ // Using startsWith because Path adds a trailing backslash to
+ // UNC roots. The second check accounts for Windows Path
+ // implementation flipping slashes on Unix paths.
+ if (!(doc.getRoot().toString().startsWith(root.getPath()) ||
+ root.getPath().equals(doc.getRoot().toString().replace('\\', '/')))) {
+ throw new FileNotFoundException("not found: " + doc.toString());
+ }
+ } else if (iter.hasNext()) {
+ if (!(root.getPath().equals(iter.next().toString()))) {
+ throw new FileNotFoundException("not found: " + doc.toString());
+ }
+ }
+ while (iter.hasNext()) {
+ file = file.getChild(iter.next().toString());
+ }
+ return file;
+ }
+
+ @Override
+ public Path getPath(String pathname) throws IOException {
+ Preconditions.checkNotNull(pathname, "pathname cannot be null");
+ return Paths.get(pathname);
+ }
+
+ @Override
+ public boolean isDirectory(Path doc) throws IOException {
+ try {
+ return getFile(doc).isDirectory();
+ } catch (FileNotFoundException e) {
+ return false;
+ }
+ }
+
+ @Override
+ public boolean isRegularFile(Path doc) throws IOException {
+ try {
+ return getFile(doc).isRegularFile();
+ } catch (FileNotFoundException e) {
+ return false;
+ }
+ }
+
+ @Override
+ public boolean isHidden(Path doc) throws IOException {
+ try {
+ return getFile(doc).isHidden();
+ } catch (FileNotFoundException e) {
+ return false;
+ }
+ }
+
+ @Override
+ public BasicFileAttributes readBasicAttributes(Path doc) throws IOException {
+ return getFile(doc).readBasicAttributes();
+ }
+
+ @Override
+ public void setLastAccessTime(Path doc, FileTime time) throws IOException {
+ getFile(doc).setLastAccessTime(time);
+ }
+
+ @Override
+ public String probeContentType(Path doc) throws IOException {
+ return getFile(doc).getContentType();
+ }
+
+ @Override
+ public InputStream newInputStream(Path doc) throws IOException {
+ return getFile(doc).newInputStream();
+ }
+
+ @Override
+ public DirectoryStream<Path> newDirectoryStream(Path doc) throws IOException {
+ return getFile(doc).newDirectoryStream();
+ }
+
+ @Override
+ public DocId newDocId(Path doc) throws IOException {
+ String id = doc.toString().replace('\\', '/');
+ if (isDirectory(doc) && !id.endsWith("/")) {
+ id += "/";
+ }
+ if (id.startsWith("//")) {
+ // String.replaceFirst uses regular expression string and replacement
+ // so they need to be escaped appropriately. The above String.replace
+ // does NOT use expressions so regex escaping is not needed.
+ id = id.replaceFirst("//", "\\\\\\\\");
+ }
+ return new DocId(id);
+ }
+
+ @Override
+ public AclFileAttributeViews getAclViews(Path doc) throws IOException {
+ MockFile file = getFile(doc);
+ return new AclFileAttributeViews(file.getAclView(),
+ file.getInheritedAclView());
+ }
+
+ @Override
+ public AclFileAttributeView getShareAclView(Path doc) throws IOException {
+ return root.getShareAclView();
+ }
+
+ @Override
+ public AclFileAttributeView getDfsShareAclView(Path doc) throws IOException {
+ return root.getDfsShareAclView();
+ }
+
+ @Override
+ public Path getDfsUncActiveStorageUnc(Path doc) throws IOException {
+ return root.getDfsUncActiveStorageUnc();
+ }
+
+ @Override
+ public void startMonitorPath(Path watchPath, BlockingQueue<Path> queue)
+ throws IOException {
+ // TODO (bmj): implementation
+ }
+
+ @Override
+ public void stopMonitorPath() {
+ // TODO (bmj): implementation
+ }
+
+ @Override
+ public void destroy() {
+ stopMonitorPath();
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/MockFileDelegateTest.java b/test/com/google/enterprise/adaptor/fs/MockFileDelegateTest.java
new file mode 100644
index 0000000..91f85f8
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockFileDelegateTest.java
@@ -0,0 +1,222 @@
+// 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 com.google.enterprise.adaptor.DocId;
+
+import org.junit.*;
+import org.junit.rules.ExpectedException;
+
+import java.io.File;
+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 MockFileDelegate}.
+ */
+public class MockFileDelegateTest {
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void testConstructorNullRoot() throws Exception {
+ thrown.expect(NullPointerException.class);
+ new MockFileDelegate(null);
+ }
+
+ @Test
+ public void testGetPathNullPathname() throws Exception {
+ thrown.expect(NullPointerException.class);
+ new MockFileDelegate(new MockFile("root", true)).getPath(null);
+ }
+
+ @Test
+ public void testGetPath() throws Exception {
+ String delim = File.separator;
+ FileDelegate delegate = new MockFileDelegate(new MockFile("root", true));
+ assertEquals("root", delegate.getPath("root").toString());
+ assertEquals("root" + delim + "foo" + delim + "bar",
+ delegate.getPath("root/foo/bar").toString());
+ assertEquals(delim + "foo" + delim + "bar" + delim + "baz",
+ delegate.getPath("/foo/bar/baz").toString());
+ assertEquals("\\\\server\\share\\dir\\file.txt",
+ delegate.getPath("\\\\server\\share\\dir\\file.txt").toString());
+ }
+
+ @Test
+ public void testGetFileNotFound() throws Exception {
+ MockFile root = new MockFile("root", true).addChildren(new MockFile("foo"));
+ MockFileDelegate delegate = new MockFileDelegate(root);
+ thrown.expect(FileNotFoundException.class);
+ delegate.getFile(delegate.getPath("root/nonExistent"));
+ }
+
+ @Test
+ public void testGetFileRelativeRoot() throws Exception {
+ testGetFile("root");
+ }
+
+ @Test
+ public void testGetFileUncRoot() throws Exception {
+ testGetFile("\\\\host\\share");
+ testGetFile("\\\\host\\share\\");
+ }
+
+ @Test
+ public void testGetFileUnixRoot() throws Exception {
+ testGetFile("/");
+ }
+
+ @Test
+ public void testGetFileDosRoot() throws Exception {
+ testGetFile("C:\\");
+ }
+
+ private void testGetFile(String rootPath) throws Exception {
+ MockFile root = new MockFile(rootPath, true).addChildren(
+ new MockFile("dir1", true).addChildren(new MockFile("foo")),
+ new MockFile("dir2", true).addChildren(new MockFile("bar")),
+ new MockFile("test.txt"));
+ MockFileDelegate delegate = new MockFileDelegate(root);
+
+ assertSame(root, delegate.getFile(delegate.getPath(rootPath)));
+ testGetFile(delegate, getPath(rootPath, "test.txt"));
+ testGetFile(delegate, getPath(rootPath, "dir1"));
+ testGetFile(delegate, getPath(rootPath, "dir2"));
+ testGetFile(delegate, getPath(rootPath, "dir1/foo"));
+ testGetFile(delegate, getPath(rootPath, "dir2/bar"));
+ }
+
+ private String getPath(String parent, String child) {
+ return (parent.endsWith("/")) ? parent + child : parent + "/" + child;
+ }
+
+ private void testGetFile(MockFileDelegate delegate, String pathname)
+ throws Exception {
+ Path path = delegate.getPath(pathname);
+ MockFile file = delegate.getFile(path);
+ assertEquals(pathname, file.getPath());
+ MockFile parent = file.getParent();
+ if (parent != null) {
+ assertSame(parent, delegate.getFile(path.getParent()));
+ }
+ }
+
+ @Test
+ public void testNewDocId() throws Exception {
+ MockFile root = new MockFile("root", true).addChildren(
+ new MockFile("dir1", true).addChildren(new MockFile("foo")));
+ FileDelegate delegate = new MockFileDelegate(root);
+ assertEquals(new DocId("root/"), getDocId(delegate, "root"));
+ assertEquals(new DocId("root/dir1/"), getDocId(delegate, "root/dir1"));
+ assertEquals(new DocId("root/dir1/foo"),
+ getDocId(delegate, "root/dir1/foo"));
+ }
+
+ private DocId getDocId(FileDelegate delegate, String pathname)
+ throws Exception {
+ return delegate.newDocId(delegate.getPath(pathname));
+ }
+
+ @Test
+ public void testSetLastAccessTime() throws Exception {
+ MockFile root = new MockFile("root", true)
+ .addChildren(new MockFile("test.txt"));
+ FileDelegate delegate = new MockFileDelegate(root);
+ Path path = delegate.getPath("root/test.txt");
+
+ BasicFileAttributes attrs = delegate.readBasicAttributes(path);
+ assertEquals(MockFile.DEFAULT_FILETIME, attrs.lastAccessTime());
+
+ FileTime accessTime = FileTime.fromMillis(40000);
+ delegate.setLastAccessTime(path, accessTime);
+ attrs = delegate.readBasicAttributes(path);
+ assertEquals(accessTime, attrs.lastAccessTime());
+ }
+
+ /**
+ * Most of the MockDelegate methods are simple passthrough calls to the
+ * MockFile methods. This is a sanity check to make sure I'm calling the
+ * right ones.
+ */
+ @Test
+ public void testPassthroughGetters() throws Exception {
+ FileTime createTime = FileTime.fromMillis(20000);
+ FileTime modifyTime = FileTime.fromMillis(30000);
+ FileTime accessTime = FileTime.fromMillis(40000);
+ String content = "<html><title>Hello World</title></html>";
+ MockFile root = new MockFile("root", true)
+ .addChildren(
+ new MockFile("test.html").setCreationTime(createTime)
+ .setLastModifiedTime(modifyTime).setLastAccessTime(accessTime)
+ .setFileContents(content).setContentType("text/html"));
+
+ FileDelegate delegate = new MockFileDelegate(root);
+ Path path = delegate.getPath("root");
+ assertTrue(delegate.isDirectory(path));
+ assertFalse(delegate.isRegularFile(path));
+ assertNull(delegate.getDfsUncActiveStorageUnc(path));
+ Path uncPath = delegate.getPath("\\\\server\\share");
+ root.setDfsUncActiveStorageUnc(uncPath);
+ assertEquals(uncPath, delegate.getDfsUncActiveStorageUnc(path));
+ assertNull(delegate.getDfsShareAclView(path));
+ root.setDfsShareAclView(MockFile.FULL_ACCESS_ACLVIEW);
+ assertEquals(MockFile.FULL_ACCESS_ACLVIEW,
+ delegate.getDfsShareAclView(path));
+ AclFileAttributeViews aclViews = delegate.getAclViews(path);
+ assertNotNull(aclViews);
+ assertEquals(MockFile.FULL_ACCESS_ACLVIEW, aclViews.getDirectAclView());
+ assertEquals(MockFile.EMPTY_ACLVIEW, aclViews.getInheritedAclView());
+
+ path = delegate.getPath("root/test.html");
+ assertTrue(delegate.isRegularFile(path));
+ assertFalse(delegate.isDirectory(path));
+ assertFalse(delegate.isHidden(path));
+ assertEquals("text/html", delegate.probeContentType(path));
+ assertEquals(content, readContents(delegate, path));
+ aclViews = delegate.getAclViews(path);
+ assertNotNull(aclViews);
+ assertEquals(MockFile.EMPTY_ACLVIEW, aclViews.getDirectAclView());
+ assertEquals(MockFile.FULL_ACCESS_ACLVIEW, aclViews.getInheritedAclView());
+
+ BasicFileAttributes attrs = delegate.readBasicAttributes(path);
+ assertTrue(attrs.isRegularFile());
+ assertFalse(attrs.isDirectory());
+ assertFalse(attrs.isOther());
+ assertEquals(createTime, attrs.creationTime());
+ assertEquals(modifyTime, attrs.lastModifiedTime());
+ assertEquals(accessTime, attrs.lastAccessTime());
+ assertEquals(content.getBytes(Charsets.UTF_8).length, attrs.size());
+ }
+
+ private String readContents(FileDelegate delegate, Path path)
+ throws IOException {
+ return CharStreams.toString(
+ new InputStreamReader(delegate.newInputStream(path), Charsets.UTF_8));
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/MockFileTest.java b/test/com/google/enterprise/adaptor/fs/MockFileTest.java
new file mode 100644
index 0000000..c65992b
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockFileTest.java
@@ -0,0 +1,309 @@
+// 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());
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/MockRequest.java b/test/com/google/enterprise/adaptor/fs/MockRequest.java
new file mode 100644
index 0000000..850d2fa
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockRequest.java
@@ -0,0 +1,50 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 com.google.enterprise.adaptor.DocId;
+import com.google.enterprise.adaptor.Request;
+
+import java.util.Date;
+
+/** A trivial implemenation of {@link Request} */
+class MockRequest implements Request {
+ private final DocId docid;
+ private final Date lastAccess;
+
+ MockRequest(DocId docid) {
+ this(docid, null);
+ }
+
+ MockRequest(DocId docid, Date lastAccess) {
+ this.docid = docid;
+ this.lastAccess = lastAccess;
+ }
+
+ @Override
+ public boolean hasChangedSinceLastAccess(Date lastModified) {
+ return lastModified.after(lastAccess);
+ }
+
+ @Override
+ public Date getLastAccessTime() {
+ return lastAccess;
+ }
+
+ @Override
+ public DocId getDocId() {
+ return docid;
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/MockResponse.java b/test/com/google/enterprise/adaptor/fs/MockResponse.java
new file mode 100644
index 0000000..edbbaaa
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/MockResponse.java
@@ -0,0 +1,124 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 com.google.enterprise.adaptor.Acl;
+import com.google.enterprise.adaptor.Response;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * An implementation of {@link Response} that implements only those items that
+ * the adaptor uses.
+ */
+class MockResponse implements Response {
+
+ boolean notModified = false;
+ boolean notFound = false;
+ String contentType;
+ Date lastModified;
+ URI displayUrl;
+ Acl acl;
+ Map<String, String> metadata = new HashMap<String, String>();
+ Map<String, Acl> namedResources = new HashMap<String, Acl>();
+ ByteArrayOutputStream content;
+
+ @Override
+ public void respondNotModified() throws IOException {
+ notModified = true;
+ }
+
+ @Override
+ public void respondNotFound() throws IOException {
+ notFound = true;
+ }
+
+ @Override
+ public OutputStream getOutputStream() throws IOException {
+ content = new ByteArrayOutputStream();
+ return content;
+ }
+
+ @Override
+ public void setContentType(String contentType) {
+ this.contentType = contentType;
+ }
+
+ @Override
+ public void setLastModified(Date lastModified) {
+ this.lastModified = lastModified;
+ }
+
+ @Override
+ public void addMetadata(String key, String value) {
+ metadata.put(key, value);
+ }
+
+ @Override
+ public void setAcl(Acl acl) {
+ this.acl = acl;
+ }
+
+ @Override
+ public void putNamedResource(String fragment, Acl acl) {
+ namedResources.put(fragment, acl);
+ }
+
+ @Override
+ public void setDisplayUrl(URI displayUrl) {
+ this.displayUrl = displayUrl;
+ }
+
+ @Override
+ public void setSecure(boolean secure) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void addAnchor(URI uri, String text) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setNoIndex(boolean noIndex) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setNoFollow(boolean noFollow) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setNoArchive(boolean noArchive) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setCrawlOnce(boolean crawlOnce) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void setLock(boolean lock) {
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/NioFileDelegateTest.java b/test/com/google/enterprise/adaptor/fs/NioFileDelegateTest.java
index ae5eaa7..4db3dce 100644
--- a/test/com/google/enterprise/adaptor/fs/NioFileDelegateTest.java
+++ b/test/com/google/enterprise/adaptor/fs/NioFileDelegateTest.java
@@ -45,15 +45,16 @@
public TemporaryFolder temp = new TemporaryFolder();
private Path newTempDir(String name) throws IOException {
- return temp.newFolder(name).toPath();
+ return temp.newFolder(name).toPath().toRealPath();
}
private Path newTempFile(String name) throws IOException {
- return temp.newFile(name).toPath();
+ return temp.newFile(name).toPath().toRealPath();
}
private Path newTempFile(Path parent, String name) throws IOException {
- Preconditions.checkArgument(parent.startsWith(temp.getRoot().toPath()));
+ Preconditions.checkArgument(parent.startsWith(temp.getRoot().toPath()
+ .toRealPath()));
return Files.createFile(parent.resolve(name));
}
@@ -162,7 +163,7 @@
@Test
public void testNewDocId() throws Exception {
- Path root = temp.getRoot().toPath();
+ Path root = temp.getRoot().toPath().toRealPath();
Path dir = newTempDir("testDir");
Path file = newTempFile(dir, "test");
diff --git a/test/com/google/enterprise/adaptor/fs/UnsupportedDocIdPusher.java b/test/com/google/enterprise/adaptor/fs/UnsupportedDocIdPusher.java
new file mode 100644
index 0000000..e9b3439
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/UnsupportedDocIdPusher.java
@@ -0,0 +1,83 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+//
+// 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 com.google.enterprise.adaptor.Acl;
+import com.google.enterprise.adaptor.DocId;
+import com.google.enterprise.adaptor.DocIdPusher;
+import com.google.enterprise.adaptor.ExceptionHandler;
+import com.google.enterprise.adaptor.GroupPrincipal;
+import com.google.enterprise.adaptor.Principal;
+
+import java.util.Collection;
+import java.util.Map;
+
+/** Throws UnsupportedOperationException for all calls. */
+class UnsupportedDocIdPusher implements DocIdPusher {
+
+ @Override
+ public DocId pushDocIds(Iterable<DocId> docIds)
+ throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DocId pushDocIds(Iterable<DocId> docIds,
+ ExceptionHandler handler)
+ throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Record pushRecords(Iterable<Record> records)
+ throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public Record pushRecords(Iterable<Record> records,
+ ExceptionHandler handler)
+ throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DocId pushNamedResources(Map<DocId, Acl> resources)
+ throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public DocId pushNamedResources(Map<DocId, Acl> resources,
+ ExceptionHandler handler)
+ throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public GroupPrincipal pushGroupDefinitions(
+ Map<GroupPrincipal, ? extends Collection<Principal>> defs,
+ boolean caseSensitive) throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public GroupPrincipal pushGroupDefinitions(
+ Map<GroupPrincipal, ? extends Collection<Principal>> defs,
+ boolean caseSensitive, ExceptionHandler handler)
+ throws InterruptedException {
+ throw new UnsupportedOperationException();
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/WindowsAclFileAttributeViewsTest.java b/test/com/google/enterprise/adaptor/fs/WindowsAclFileAttributeViewsTest.java
new file mode 100644
index 0000000..2b87cbe
--- /dev/null
+++ b/test/com/google/enterprise/adaptor/fs/WindowsAclFileAttributeViewsTest.java
@@ -0,0 +1,340 @@
+// Copyright 2014 Google Inc. All Rights Reserved.
+//
+// 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 static org.junit.Assume.*;
+
+import org.junit.*;
+import org.junit.rules.ExpectedException;
+
+import com.sun.jna.platform.win32.Advapi32Util.Account;
+import com.sun.jna.platform.win32.Win32Exception;
+import com.sun.jna.platform.win32.WinError;
+import com.sun.jna.platform.win32.WinNT;
+import com.sun.jna.platform.win32.WinNT.SID_NAME_USE;
+
+import java.nio.file.attribute.AclEntry;
+import java.nio.file.attribute.AclEntryFlag;
+import java.nio.file.attribute.AclEntryPermission;
+import java.nio.file.attribute.AclEntryType;
+import java.nio.file.attribute.GroupPrincipal;
+import java.nio.file.attribute.UserPrincipal;
+import java.util.EnumSet;
+import java.util.Set;
+
+/** Tests for {@link WindowsAclFileAttributeViews} */
+public class WindowsAclFileAttributeViewsTest {
+
+ private final WindowsAclFileAttributeViews wafav =
+ new TestAclFileAttributeViews();
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void testNewAclEntryUnsupportedAccessType() throws Exception {
+ WinNT.ACCESS_ACEStructure ace = new AceBuilder()
+ .setType(WinNT.SYSTEM_AUDIT_ACE_TYPE).build();
+ assertNull(wafav.newAclEntry(ace));
+ }
+
+ @Test
+ public void testNewAclEntryUnresolvableSid() throws Exception {
+ TestHelper.assumeOsIsWindows(); // For new Win32Exception().
+ WinNT.ACCESS_ACEStructure ace = new AceBuilder()
+ .setSid(new AccountSid(null)).build();
+ assertNull(wafav.newAclEntry(ace));
+ }
+
+ @Test
+ public void testNewAclEntryUnsupportedAccountType() throws Exception {
+ WinNT.ACCESS_ACEStructure ace = new AceBuilder()
+ .setSid(new AccountSid(SID_NAME_USE.SidTypeUnknown, "", "")).build();
+ assertNull(wafav.newAclEntry(ace));
+ }
+
+ @Test
+ public void testNewAclEntryUserPrincipal() throws Exception {
+ testNewAclEntryUserPrincipal(AccountSid.user("userName", null), "userName");
+ }
+
+ @Test
+ public void testNewAclEntryUserWithDomainPrincipal() throws Exception {
+ testNewAclEntryUserPrincipal(AccountSid.user("userName", "domain"),
+ "domain\\userName");
+ }
+
+ private void testNewAclEntryUserPrincipal(AccountSid account,
+ String expectedName) throws Exception {
+ WinNT.ACCESS_ACEStructure ace = new AceBuilder().setSid(account).build();
+ AclEntry aclEntry = wafav.newAclEntry(ace);
+ assertNotNull(aclEntry);
+ UserPrincipal principal = aclEntry.principal();
+ assertNotNull(principal);
+ assertFalse(principal instanceof GroupPrincipal);
+ assertEquals(expectedName, principal.getName());
+ }
+
+ @Test
+ public void testNewAclEntryGroupPrincipal() throws Exception {
+ testNewAclEntryGroupPrincipal(AccountSid.group("groupName", null),
+ "groupName");
+ }
+
+ @Test
+ public void testNewAclEntryGroupWithDomainPrincipal() throws Exception {
+ testNewAclEntryGroupPrincipal(AccountSid.group("groupName", "domain"),
+ "domain\\groupName");
+ }
+
+ @Test
+ public void testNewAclEntryAliasPrincipal() throws Exception {
+ AccountSid account =
+ new AccountSid(SID_NAME_USE.SidTypeAlias, "alias", "domain");
+ testNewAclEntryGroupPrincipal(account, "domain\\alias");
+ }
+
+ @Test
+ public void testNewAclEntryWellKnownGroupPrincipal() throws Exception {
+ AccountSid account =
+ new AccountSid(SID_NAME_USE.SidTypeWellKnownGroup, "wellKnown", null);
+ testNewAclEntryGroupPrincipal(account, "wellKnown");
+ }
+
+ private void testNewAclEntryGroupPrincipal(AccountSid account,
+ String expectedName) throws Exception {
+ WinNT.ACCESS_ACEStructure ace = new AceBuilder().setSid(account).build();
+ AclEntry aclEntry = wafav.newAclEntry(ace);
+ assertNotNull(aclEntry);
+ UserPrincipal principal = aclEntry.principal();
+ assertNotNull(principal);
+ assertTrue(principal instanceof GroupPrincipal);
+ assertEquals(expectedName, principal.getName());
+ }
+
+ @Test
+ public void testNewAclEntryIndividualPermissions() throws Exception {
+ testNewAclEntryPermissions(WinNT.FILE_READ_DATA,
+ AclEntryPermission.READ_DATA);
+ testNewAclEntryPermissions(WinNT.FILE_READ_ATTRIBUTES,
+ AclEntryPermission.READ_ATTRIBUTES);
+ testNewAclEntryPermissions(WinNT.FILE_READ_EA,
+ AclEntryPermission.READ_NAMED_ATTRS);
+ testNewAclEntryPermissions(WinNT.READ_CONTROL,
+ AclEntryPermission.READ_ACL);
+ testNewAclEntryPermissions(WinNT.FILE_WRITE_DATA,
+ AclEntryPermission.WRITE_DATA);
+ testNewAclEntryPermissions(WinNT.FILE_APPEND_DATA,
+ AclEntryPermission.APPEND_DATA);
+ testNewAclEntryPermissions(WinNT.FILE_WRITE_ATTRIBUTES,
+ AclEntryPermission.WRITE_ATTRIBUTES);
+ testNewAclEntryPermissions(WinNT.FILE_WRITE_EA,
+ AclEntryPermission.WRITE_NAMED_ATTRS);
+ testNewAclEntryPermissions(WinNT.WRITE_DAC,
+ AclEntryPermission.WRITE_ACL);
+ testNewAclEntryPermissions(WinNT.WRITE_OWNER,
+ AclEntryPermission.WRITE_OWNER);
+ testNewAclEntryPermissions(WinNT.DELETE,
+ AclEntryPermission.DELETE);
+ testNewAclEntryPermissions(WinNT.FILE_DELETE_CHILD,
+ AclEntryPermission.DELETE_CHILD);
+ testNewAclEntryPermissions(WinNT.SYNCHRONIZE,
+ AclEntryPermission.SYNCHRONIZE);
+ testNewAclEntryPermissions(WinNT.FILE_EXECUTE,
+ AclEntryPermission.EXECUTE);
+ }
+
+ @Test
+ public void testNewAclEntryFullPermissions() throws Exception {
+ testNewAclEntryPermissions(WinNT.FILE_ALL_ACCESS,
+ AclEntryPermission.values());
+
+ }
+
+ @Test
+ public void testNewAclEntryGenericPermissions() throws Exception {
+ testNewAclEntryPermissions(WinNT.GENERIC_READ, AclEntryPermission.READ_DATA,
+ AclEntryPermission.READ_ATTRIBUTES, AclEntryPermission.READ_NAMED_ATTRS,
+ AclEntryPermission.READ_ACL, AclEntryPermission.SYNCHRONIZE);
+ testNewAclEntryPermissions(WinNT.GENERIC_WRITE,
+ AclEntryPermission.WRITE_DATA, AclEntryPermission.APPEND_DATA,
+ AclEntryPermission.READ_ACL, AclEntryPermission.WRITE_ATTRIBUTES,
+ AclEntryPermission.WRITE_NAMED_ATTRS, AclEntryPermission.SYNCHRONIZE);
+ testNewAclEntryPermissions(WinNT.GENERIC_EXECUTE,
+ AclEntryPermission.EXECUTE, AclEntryPermission.READ_ATTRIBUTES,
+ AclEntryPermission.READ_ACL, AclEntryPermission.SYNCHRONIZE);
+ testNewAclEntryPermissions(WinNT.GENERIC_ALL, AclEntryPermission.values());
+ }
+
+ private void testNewAclEntryPermissions(int acePermissions,
+ AclEntryPermission... expectedPermissions) throws Exception {
+ Set<AclEntryPermission> expected =
+ EnumSet.noneOf(AclEntryPermission.class);
+ for (AclEntryPermission perm : expectedPermissions) {
+ expected.add(perm);
+ }
+ WinNT.ACCESS_ACEStructure ace = new AceBuilder()
+ .setSid(AccountSid.user("userName", null))
+ .setPerms(acePermissions)
+ .build();
+ AclEntry aclEntry = wafav.newAclEntry(ace);
+ assertNotNull(aclEntry);
+ assertEquals(expected, aclEntry.permissions());
+ }
+
+ @Test
+ public void testNewAclEntryIndividualFlags() throws Exception {
+ testNewAclEntryFlags(WinNT.OBJECT_INHERIT_ACE, AclEntryFlag.FILE_INHERIT);
+ testNewAclEntryFlags(WinNT.INHERIT_ONLY_ACE, AclEntryFlag.INHERIT_ONLY);
+ testNewAclEntryFlags(WinNT.CONTAINER_INHERIT_ACE,
+ AclEntryFlag.DIRECTORY_INHERIT);
+ testNewAclEntryFlags(WinNT.NO_PROPAGATE_INHERIT_ACE,
+ AclEntryFlag.NO_PROPAGATE_INHERIT);
+ }
+
+ @Test
+ public void testNewAclEntryMultipleFlags() throws Exception {
+ testNewAclEntryFlags((byte) (WinNT.OBJECT_INHERIT_ACE |
+ WinNT.CONTAINER_INHERIT_ACE | WinNT.INHERIT_ONLY_ACE |
+ WinNT.NO_PROPAGATE_INHERIT_ACE), AclEntryFlag.values());
+ }
+
+ private void testNewAclEntryFlags(byte aceFlags,
+ AclEntryFlag... expectedFlags) throws Exception {
+ Set<AclEntryFlag> expected = EnumSet.noneOf(AclEntryFlag.class);
+ for (AclEntryFlag flag : expectedFlags) {
+ expected.add(flag);
+ }
+ WinNT.ACCESS_ACEStructure ace = new AceBuilder()
+ .setSid(AccountSid.user("userName", null))
+ .setFlags(aceFlags)
+ .build();
+ AclEntry aclEntry = wafav.newAclEntry(ace);
+ assertNotNull(aclEntry);
+ assertEquals(expected, aclEntry.flags());
+ }
+
+ static class AceBuilder {
+ private Ace ace = new Ace();
+
+ public AceBuilder setType(byte type) {
+ ace.AceType = type;
+ return this;
+ }
+
+ public AceBuilder setFlags(byte... flags) {
+ for (byte flag : flags) {
+ ace.AceFlags |= flag;
+ }
+ return this;
+ }
+
+ public AceBuilder setPerms(int... perms) {
+ for (int perm : perms) {
+ ace.Mask |= perm;
+ }
+ return this;
+ }
+
+ public AceBuilder setSid(WinNT.PSID sid) {
+ ace.setSID(sid);
+ return this;
+ }
+
+ public WinNT.ACCESS_ACEStructure build() {
+ return ace;
+ }
+ }
+
+ static class Ace extends WinNT.ACCESS_ACEStructure {
+ // psid is not publicly settable in ACCESS_ACEStructure.
+ private WinNT.PSID sid;
+
+ public void setSID(WinNT.PSID sid) {
+ this.sid = sid;
+ }
+
+ @Override
+ public WinNT.PSID getSID() {
+ return (sid != null) ? sid : super.getSID();
+ }
+
+ @Override
+ public String getSidString() {
+ return (sid != null) ? sid.toString() : super.getSidString();
+ }
+ }
+
+ /** A SID implemention that wraps an Account, avoiding AD lookup. */
+ static class AccountSid extends WinNT.PSID {
+ private final Account account;
+
+ public static AccountSid user(String name, String domain) {
+ return new AccountSid(SID_NAME_USE.SidTypeUser, name, domain);
+ }
+
+ public static AccountSid group(String name, String domain) {
+ return new AccountSid(SID_NAME_USE.SidTypeGroup, name, domain);
+ }
+
+ public AccountSid(Account account) {
+ this.account = account;
+ }
+
+ public AccountSid(int type, String name, String domain) {
+ account = new Account();
+ account.accountType = type;
+ account.name = name;
+ account.domain = domain;
+ }
+
+ public Account getAccount() throws Win32Exception {
+ if (account == null) {
+ throw new Win32Exception(WinError.ERROR_NONE_MAPPED);
+ }
+ return account;
+ }
+
+ @Override
+ public String toString() {
+ if (account == null) {
+ return "null";
+ } else {
+ return (account.domain == null) ? account.name
+ : account.domain + "\\" + account.name;
+ }
+ }
+ }
+
+ /**
+ * An subclass of WindowsAclFileAttributeViews that avoids making
+ * actual Windows API calls.
+ */
+ static class TestAclFileAttributeViews extends WindowsAclFileAttributeViews {
+ public TestAclFileAttributeViews() {
+ super(null, null, null, null, null);
+ }
+
+ @Override
+ Account getAccountBySid(WinNT.PSID sid) throws Win32Exception {
+ if (sid instanceof AccountSid) {
+ return ((AccountSid) sid).getAccount();
+ } else {
+ return super.getAccountBySid(sid);
+ }
+ }
+ }
+}
diff --git a/test/com/google/enterprise/adaptor/fs/WindowsFileDelegateTest.java b/test/com/google/enterprise/adaptor/fs/WindowsFileDelegateTest.java
index f345598..0a536eb 100644
--- a/test/com/google/enterprise/adaptor/fs/WindowsFileDelegateTest.java
+++ b/test/com/google/enterprise/adaptor/fs/WindowsFileDelegateTest.java
@@ -72,11 +72,11 @@
}
private Path newTempDir(String name) throws IOException {
- return temp.newFolder(name).toPath();
+ return temp.newFolder(name).toPath().toRealPath();
}
private Path newTempFile(String name) throws IOException {
- return temp.newFile(name).toPath();
+ return temp.newFile(name).toPath().toRealPath();
}
private Path newTempFile(Path parent, String name) throws IOException {
