test/com/google/enterprise/adaptor/fs/MockFileDelegateTest.java

// 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));
  }
}