src/test/java/com/google/devtools/build/lib/blackbox/framework/PathUtilsTest.java

// Copyright 2018 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.blackbox.framework;

import static com.google.common.truth.Truth.assertThat;

import com.google.devtools.build.lib.util.OS;
import com.google.devtools.build.lib.util.StringUtilities;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Collections;
import java.util.List;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

/** Test for {@link PathUtils}. */
@RunWith(JUnit4.class)
public class PathUtilsTest {
  @Test
  public void testDeleteTree() throws IOException {
    Path directory = Files.createTempDirectory("test");

    Path subDir = subDir(directory, "subdir");
    write(subDir, "file1.txt", "Hello!");
    write(subDir, "file2.txt", "I am here!");

    Path innerDir = subDir(subDir, "inner");
    write(innerDir, "inner.txt", "Deep");

    subDir(subDir, "empty");

    PathUtils.deleteTree(directory);

    assertThat(Files.exists(directory)).isFalse();
  }

  @Test
  public void testCopyTree() throws IOException {
    Path source = Files.createTempDirectory("source");
    Path target = Files.createTempDirectory("target");

    try {
      Path subDir = subDir(source, "subdir");
      write(subDir, "file1.txt", "Hello!");
      write(subDir, "file2.txt", "I am here!");

      Path innerDir = subDir(subDir, "inner");
      write(innerDir, "inner.txt", "Deep");

      subDir(subDir, "empty");

      PathUtils.copyTree(source, target);

      Path targetSubdir = resolveDirectory(target, "subdir");
      Path targetInner = resolveDirectory(targetSubdir, "inner");
      resolveDirectory(targetSubdir, "empty");

      assertFileExists(targetSubdir, "file1.txt", "Hello!");
      assertFileExists(targetSubdir, "file2.txt", "I am here!");

      assertFileExists(targetInner, "inner.txt", "Deep");
    } finally {
      PathUtils.deleteTree(source);
      PathUtils.deleteTree(target);
    }
  }

  @Test
  public void testResolve() throws IOException {
    Path directory = Files.createTempDirectory("test");
    try {
      Path expected = directory.resolve("subdir").resolve("inner").resolve("file.txt");
      Path resolved = PathUtils.resolve(directory, "subdir", "inner", "file.txt");
      // can not use assertThat here, because Path implements Iterable and there is ambiguity
      // in overloaded methods resolution between assertThat(T) and assertThat(Iterable<T>)
      Assert.assertEquals(expected, resolved);
      assertThat(resolved.getFileName().toString()).isEqualTo("file.txt");
    } finally {
      PathUtils.deleteTree(directory);
    }
  }

  @Test
  public void testCreateFile() throws IOException {
    Path directory = Files.createTempDirectory("test");
    try {
      Path resolved = PathUtils.resolve(directory, "a", "b", "c");
      assertThat(Files.exists(resolved)).isFalse();

      PathUtils.createFile(resolved);

      assertThat(Files.exists(resolved)).isTrue();
      assertThat(Files.isRegularFile(resolved)).isTrue();
    } finally {
      PathUtils.deleteTree(directory);
    }
  }

  @Test
  public void testCreateFileChained() throws IOException {
    Path directory = Files.createTempDirectory("test");
    try {
      Path resolved = PathUtils.resolve(directory, "a", "b", "c");
      assertThat(Files.exists(resolved)).isFalse();

      Path created = PathUtils.createFile(directory, "a/b/c");
      assertThat(Files.exists(created)).isTrue();
      assertThat(Files.isRegularFile(created)).isTrue();
      // can not use assertThat here, because Path implements Iterable and there is ambiguity
      // in overloaded methods resolution between assertThat(T) and assertThat(Iterable<T>)
      Assert.assertEquals(resolved, created);
    } finally {
      PathUtils.deleteTree(directory);
    }
  }

  @Test
  public void testRewriteExistingFile() throws IOException {
    Path directory = Files.createTempDirectory("test");
    try {
      Path file = PathUtils.createFile(directory, "file.txt");
      assertThat(Files.exists(file)).isTrue();
      assertThat(Files.isRegularFile(file)).isTrue();

      PathUtils.writeFile(file, "Variant1");
      List<String> contents1 = PathUtils.readFile(file);
      assertThat(contents1).hasSize(1);
      assertThat(contents1.get(0)).isEqualTo("Variant1");

      PathUtils.writeFile(file, "Variant2");
      List<String> contents2 = PathUtils.readFile(file);
      assertThat(contents2).hasSize(1);
      assertThat(contents2.get(0)).isEqualTo("Variant2");
    } finally {
      PathUtils.deleteTree(directory);
    }
  }

  @Test
  public void testReadWriteAppend() throws IOException {
    Path directory = Files.createTempDirectory("test");
    try {
      Path file = PathUtils.createFile(directory, "file.txt");
      PathUtils.writeFile(file, "line 1");
      assertThat(Files.exists(file)).isTrue();

      List<String> linesBefore = PathUtils.readFile(file);
      assertThat(linesBefore).hasSize(1);
      assertThat(linesBefore.get(0)).isEqualTo("line 1");

      PathUtils.append(file, "line 2");

      List<String> lines = PathUtils.readFile(file);
      assertThat(lines).hasSize(2);
      assertThat(lines.get(0)).isEqualTo("line 1");
      assertThat(lines.get(1)).isEqualTo("line 2");
    } finally {
      PathUtils.deleteTree(directory);
    }
  }

  @Test
  public void testReplaceWithSymlinkContents() throws IOException {
    // do not run the test for windows
    if (!OS.isPosixCompatible()) {
      return;
    }

    Path directory = Files.createTempDirectory("test");
    try {
      Path target = PathUtils.createFile(directory, "source.txt");
      PathUtils.writeFile(target, "Target contents");
      Path link = directory.resolve("link.txt");
      Files.createSymbolicLink(link, target);

      assertThat(Files.exists(link)).isTrue();
      assertThat(Files.isSymbolicLink(link)).isTrue();

      PathUtils.replaceWithSymlinkContents(link);
      assertThat(Files.isSymbolicLink(link)).isFalse();

      List<String> lines = PathUtils.readFile(link);
      assertThat(lines).hasSize(1);
      assertThat(lines.get(0)).isEqualTo("Target contents");
    } finally {
      PathUtils.deleteTree(directory);
    }
  }

  private static void assertFileExists(Path directory, String fileName, String text)
      throws IOException {
    Path file = directory.resolve(fileName);
    assertThat(Files.exists(file)).isTrue();
    assertThat(Files.isRegularFile(file)).isTrue();
    assertThat(StringUtilities.joinLines(Files.readAllLines(file))).isEqualTo(text);
  }

  private static Path resolveDirectory(Path directory, String directoryName) {
    Path subDir = directory.resolve(directoryName);
    assertThat(Files.exists(subDir)).isTrue();
    assertThat(Files.isDirectory(subDir)).isTrue();
    return subDir;
  }

  private static Path subDir(Path directory, String directoryName) throws IOException {
    Path subDir = directory.resolve(directoryName);
    Files.createDirectories(subDir);
    subDir.toFile().deleteOnExit();
    return subDir;
  }

  private static void write(Path directory, String fileName, String text) throws IOException {
    Path file = directory.resolve(fileName);
    write(file, text);
  }

  private static void write(Path path, String text) throws IOException {
    assertThat(path.toFile().createNewFile()).isTrue();
    Files.write(path, Collections.singleton(text));
    path.toFile().deleteOnExit();
  }
}