src/test/java/com/google/devtools/build/lib/vfs/ZipFileSystemTest.java

// Copyright 2014 The Bazel Authors. 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.devtools.build.lib.vfs;

import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import com.google.common.collect.Lists;
import com.google.common.io.CharStreams;
import com.google.devtools.build.lib.testutil.BlazeTestUtils;
import com.google.devtools.build.lib.testutil.TestConstants;
import com.google.devtools.build.lib.vfs.util.FileSystems;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

@RunWith(JUnit4.class)
public class ZipFileSystemTest {

  /**
   * Expected listing of sample zip files, in alpha sorted order
   */
  private static final String[] LISTING = {
    "/dir1",
    "/dir1/file1a",
    "/dir1/file1b",
    "/dir2",
    "/dir2/dir3",
    "/dir2/dir3/dir4",
    "/dir2/dir3/dir4/file4",
    "/dir2/file2",
    "/file0",
  };

  private FileSystem zipFS1;
  private FileSystem zipFS2;

  @Before
  public final void initializeFileSystems() throws Exception  {
    FileSystem unixFs = FileSystems.getNativeFileSystem();
    Path testdataDir = unixFs.getPath(BlazeTestUtils.runfilesDir()).getRelative(
        TestConstants.JAVATESTS_ROOT + "/com/google/devtools/build/lib/vfs");
    Path zPath1 = testdataDir.getChild("sample_with_dirs.zip");
    Path zPath2 = testdataDir.getChild("sample_without_dirs.zip");
    zipFS1 = new ZipFileSystem(zPath1);
    zipFS2 = new ZipFileSystem(zPath2);
  }

  private void checkExists(FileSystem fs) {
    assertTrue(fs.getPath("/dir2/dir3/dir4").exists());
    assertTrue(fs.getPath("/dir2/dir3/dir4/file4").exists());
    assertFalse(fs.getPath("/dir2/dir3/dir4/bogus").exists());
  }

  @Test
  public void testExists() {
    checkExists(zipFS1);
    checkExists(zipFS2);
  }

  private void checkIsFile(FileSystem fs) {
    assertFalse(fs.getPath("/dir2/dir3/dir4").isFile());
    assertTrue(fs.getPath("/dir2/dir3/dir4/file4").isFile());
    assertFalse(fs.getPath("/dir2/dir3/dir4/bogus").isFile());
  }

  @Test
  public void testIsFile() {
    checkIsFile(zipFS1);
    checkIsFile(zipFS2);
  }

  private void checkIsDir(FileSystem fs) {
    assertTrue(fs.getPath("/dir2/dir3/dir4").isDirectory());
    assertFalse(fs.getPath("/dir2/dir3/dir4/file4").isDirectory());
    assertFalse(fs.getPath("/bogus/mobogus").isDirectory());
    assertFalse(fs.getPath("/bogus").isDirectory());
  }

  @Test
  public void testIsDir() {
    checkIsDir(zipFS1);
    checkIsDir(zipFS2);
  }

  /**
   * Recursively add the contents of a given path, rendered as strings, into a
   * given list.
   */
  private static void listChildren(Path p, List<String> list)
      throws IOException {
    for (Path c : p.getDirectoryEntries()) {
      list.add(c.getPathString());
      if (c.isDirectory()) {
        listChildren(c, list);
      }
    }
  }

  private void checkListing(FileSystem fs) throws Exception {
    List<String> list = new ArrayList<>();
    listChildren(fs.getRootDirectory(), list);
    Collections.sort(list);
    assertEquals(Lists.newArrayList(LISTING), list);
  }

  @Test
  public void testListing() throws Exception {
    checkListing(zipFS1);
    checkListing(zipFS2);

    // Regression test for: creation of a path (i.e. a file *name*)
    // must not affect the result of getDirectoryEntries().
    zipFS1.getPath("/dir1/notthere");
    checkListing(zipFS1);
  }

  private void checkFileSize(FileSystem fs, String name, long expectedSize)
      throws IOException {
    assertEquals(expectedSize, fs.getPath(name).getFileSize());
  }

  @Test
  public void testCanReadRoot() {
    Path rootDirectory = zipFS1.getRootDirectory();
    assertTrue(rootDirectory.isDirectory());
  }

  @Test
  public void testFileSize() throws IOException {
    checkFileSize(zipFS1, "/dir1/file1a", 5);
    checkFileSize(zipFS2, "/dir1/file1a", 5);
    checkFileSize(zipFS1, "/dir2/dir3/dir4/file4", 5000);
    checkFileSize(zipFS2, "/dir2/dir3/dir4/file4", 5000);
  }

  private void checkCantGetFileSize(FileSystem fs, String name) {
    try {
      fs.getPath(name).getFileSize();
      fail();
    } catch (IOException expected) {
      // expected
    }
  }

  @Test
  public void testCantGetFileSize() {
    checkCantGetFileSize(zipFS1, "/dir2/dir3/dir4/bogus");
    checkCantGetFileSize(zipFS2, "/dir2/dir3/dir4/bogus");
  }

  private void checkOpenFile(FileSystem fs, String name, int expectedSize)
      throws Exception {
    InputStream is = fs.getPath(name).getInputStream();
    List<String> lines = CharStreams.readLines(new InputStreamReader(is, "ISO-8859-1"));
    assertThat(lines).hasSize(expectedSize);
    for (int i = 0; i < expectedSize; i++) {
      assertEquals("body", lines.get(i));
    }
  }

  @Test
  public void testOpenSmallFile() throws Exception {
    checkOpenFile(zipFS1, "/dir1/file1a", 1);
    checkOpenFile(zipFS2, "/dir1/file1a", 1);
  }

  @Test
  public void testOpenBigFile() throws Exception {
    checkOpenFile(zipFS1, "/dir2/dir3/dir4/file4", 1000);
    checkOpenFile(zipFS2, "/dir2/dir3/dir4/file4", 1000);
  }

  private void checkCantOpenFile(FileSystem fs, String name) {
    try {
      fs.getPath(name).getInputStream();
      fail();
    } catch (IOException expected) {
      // expected
    }
  }

  @Test
  public void testCantOpenFile() throws Exception {
    checkCantOpenFile(zipFS1, "/dir2/dir3/dir4/bogus");
    checkCantOpenFile(zipFS2, "/dir2/dir3/dir4/bogus");
  }

  private void checkCantCreateAnything(FileSystem fs, String name)  {
    Path p = fs.getPath(name);
    try {
      p.createDirectory();
      fail();
    } catch (Exception expected) {}
    try {
      FileSystemUtils.createEmptyFile(p);
      fail();
    } catch (Exception expected) {}
    try {
      p.createSymbolicLink(p);
      fail();
    } catch (Exception expected) {}
  }

  @Test
  public void testCantCreateAnything() throws Exception {
    checkCantCreateAnything(zipFS1, "/dir2/dir3/dir4/new");
    checkCantCreateAnything(zipFS2, "/dir2/dir3/dir4/new");
  }

}