TfsTestCase.java

package net.sf.cotta.acceptance;

import net.sf.cotta.system.FileSystem;
import net.sf.cotta.*;
import net.sf.cotta.io.*;
import net.sf.cotta.test.assertion.CodeBlock;

import java.io.*;
import java.util.List;

public abstract class TfsTestCase extends TestCase {

  protected abstract FileSystem fileSystem();

  public void testWorkForRegularOperations() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TDirectory directory = ensureThatDirectoryCanBeCreated(factory, "tmp");
    ensureThatFileCanBeCreated(directory);
    ensureThatListDirReturnsAListOfExistingSubDirectory(factory.dir("tmp"));
    ensureThatListFilesReturnsAListOfExistingFiles(factory.dir("tmp"));
    try {
      directory.delete();
      fail("TIoException should have occurred");
    } catch (TIoException e) {
      ensure.that(e).message().contains("./tmp");
    }
  }

  private TDirectory ensureThatDirectoryCanBeCreated(TFileFactory factory, String directoryPath) throws TIoException {
    TDirectory directory = factory.dir(directoryPath);
    ensure.that(directory.name()).eq(directoryPath);
    ensure.that(directory.exists()).eq(false);
    directory.ensureExists();
    ensure.that(directory.exists()).eq(true);
    return directory;
  }

  private void ensureThatFileCanBeCreated(TDirectory directory) throws TIoException {
    TFile file = directory.file("test.txt");
    ensure.that(file.name()).eq("test.txt");
    ensure.that(file.exists()).eq(false);
    file.create();
    ensure.that(file.exists()).eq(true);
  }

  private void ensureThatListDirReturnsAListOfExistingSubDirectory(TDirectory directory) throws TIoException {
    TDirectory subDirectory = directory.dir("tmp-dir");
    ensure.that(subDirectory.name()).eq("tmp-dir");
    ensure.that(subDirectory.exists()).eq(false);
    subDirectory.ensureExists();

    ensure.that(subDirectory.exists()).eq(true);

    ensureThatContainsSubDirectory(directory, "tmp-dir");
  }

  private void ensureThatContainsSubDirectory(TDirectory directory, String subDirectoryName) throws TIoException {
    List<TDirectory> subDirectories = directory.list().dirs();
    ensure.that(subDirectories.size()).eq(1);
    ensure.that(subDirectories.get(0).exists()).eq(true);
    ensure.that(subDirectories.get(0).name()).eq(subDirectoryName);
  }

  private void ensureThatListFilesReturnsAListOfExistingFiles(TDirectory directory) throws TIoException {
    List<TFile> files = directory.list().files();
    ensure.that(files.size()).eq(1);
    ensure.that(files.get(0).exists()).eq(true);
    ensure.that(files.get(0).name()).eq("test.txt");
  }

  public void testAllowUserToStartWithAPathString() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TDirectory directory = factory.dir("tmp\\InMemoryFileTest\\subdirectory");
    ensure.that(directory.name()).eq("subdirectory");
    ensure.that(directory.parent().name()).eq("InMemoryFileTest");
    directory.ensureExists();
    TDirectory anotherDirectoryWithSamePath = factory.dir("tmp\\InMemoryFileTest\\subdirectory");
    ensure.that(anotherDirectoryWithSamePath.exists()).eq(true);

    TDirectory parent = factory.dir("tmp\\InMemoryFileTest");
    ensure.that(parent.exists()).eq(true);
    TDirectory sameChild = parent.dir("subdirectory");
    ensure.that(sameChild.exists()).eq(true);
    ensure.that(sameChild).eqWithHash(directory);
  }

  public void testMakeSureRootDirectoryAlwaysExists() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    ensure.that(factory.dir("/").exists()).eq(true);
    ensure.that(factory.dir("/tmp").parent().exists()).eq(true);
    ensure.that(factory.file("/tmp").parent().exists()).eq(true);
  }

  public void testHaveAConceptOfCurrentWorkingDirectory() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TDirectory directory = factory.dir("dir");
    ensure.that(directory.parent().name()).eq(".");
    ensure.that(directory.parent().exists()).eq(true);
    TFile file = factory.file("test.txt");
    ensure.that(file.parent().name()).eq(".");
    ensure.that(file.parent().exists()).eq(true);
  }

  public void testProvideCreationDeletionAndStatusCheckingOperationOnFiles() throws TIoException {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile file = factory.file("tmp\\FileTest\\test.txt");
    ensure.that(file.exists()).eq(false);
    ensure.that(file.parent()).eq(factory.dir("tmp\\FileTest"));
    ensure.that(file.parent().exists()).eq(false);
    file.create();
    ensure.that(file.exists()).eq(true);
    ensure.that(file.parent().exists()).eq(true);
    file.delete();
    ensure.that(file.exists()).eq(false);
    ensure.that(file.parent().exists()).eq(true);
  }

  public void testHandleTheCaseWhereFileAndDirectoryAreOfTheSameName() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile file = factory.file("tmp\\directory");
    TDirectory directory = factory.dir("tmp\\directory");
    directory.ensureExists();
    ensure.that(file.exists()).eq(false);
    try {
      file.create();
      fail("TIoException should have been thrown");
    } catch (TIoException e) {
      ensure.that(e).message().contains("directory");
    }
    TDirectory directoryWithFileName = directory.dir("file.txt");
    directory.file("file.txt").create();
    ensure.that(directoryWithFileName.exists()).eq(false);
    try {
      directoryWithFileName.ensureExists();
      fail("TIoException should have been thrown");
    } catch (TIoException e) {
      ensure.that(e).message().contains("directory");
    }
  }

  public void testSaveAndLoadFileContentDirectly() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile file = factory.file("tmp/test.txt");
    file.save("expected");
    ensure.that(file.lastModified()).gt(0);
    ensure.that(factory.file("tmp/test.txt").load()).eq("expected");
  }

  public void testProvideInputStream() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile file = factory.file("tmp/test.txt");
    file.save("");
    InputStream stream = file.inputStream();
    registerResource(stream);
    int expected = -1;
    ensure.that(stream.read()).eq(expected);
  }

  public void testProvideOutputStreamBasedOnMode() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile file = factory.file("tmp/test.txt");
    OutputStream stream = file.outputStream(OutputMode.OVERWRITE);
    registerResource(stream);
    stream.write("this is a line".getBytes());
    stream.close();
    ensure.that(file.parent().exists()).eq(true);
    List<TFile> actual = file.parent().list().files();
    ensure.that(actual.size()).eq(1);
    ensure.that(actual.get(0)).eq(file);
    ensure.that(file.load()).eq("this is a line");
    file.append(new OutputProcessor() {
      public void process(OutputManager io) throws IOException {
        io.printWriter().print("-appended");
      }
    });
    ensure.that(file.load()).eq("this is a line-appended");
    file.write(new OutputProcessor() {
      public void process(OutputManager io) throws IOException {
        io.printWriter().print("new content");
      }
    });
    final StringBuffer buffer = new StringBuffer();
    file.read(new LineProcessor() {
      public void process(String line) {
        buffer.append(line);
      }
    });
    ensure.that(buffer.toString()).eq("new content");
  }

  public void testProvideReaderAndWriter() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile file = factory.file("tmp/test.txt");
    Writer writer = new OutputStreamWriter(file.outputStream(OutputMode.APPEND));
    registerResource(writer);
    writer.write("line\n");
    writer.close();
    Reader reader = new InputStreamReader(file.inputStream());
    registerResource(reader);
    ensure.character(reader.read()).eq('l');
  }

  public void testBeAbleToAppendToFile() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile file = factory.file("tmp/test.txt");
    Writer writer = new OutputStreamWriter(file.outputStream(OutputMode.APPEND));
    registerResource(writer);
    writer.write("one");
    writer.close();
    Writer anotherWriter = new OutputStreamWriter(file.outputStream(OutputMode.APPEND));
    registerResource(anotherWriter);
    anotherWriter.write("two");
    anotherWriter.close();
    ensure.that(file.load()).eq("onetwo");
  }

  public void testThrowExceptionIfDirectoryToListDirIsNotFound() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    final TDirectory directory = factory.dir("tmp/directory");
    ensure.code(new CodeBlock() {
      public void execute() throws Exception {
        directory.list().dirs();
      }
    }).throwsException(TDirectoryNotFoundException.class);
  }

  public void testThrowExceptionIfDirectoryToListFileIsNotFound() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    final TDirectory directory = factory.dir("tmp/directory");
    ensure.code(new CodeBlock() {
      public void execute() throws Exception {
        directory.list().files();
      }
    }).throwsException(TDirectoryNotFoundException.class);
  }

  public void testSupportMoveOperation() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile source = factory.file("tmp/source.txt");
    String content = "content for the source";
    source.save(content);
    long length = source.length();
    long modified = source.lastModified();
    TFile destination = factory.file("tmp/destination.txt");
    source.moveTo(destination);
    ensure.that(source.exists()).eq(false);
    ensure.that(destination.exists()).eq(true);
    ensure.that(destination.load()).eq(content);
    ensure.that(destination.length()).eq(length);
    ensure.that(destination.lastModified()).eq(modified);
  }

  public void testThrowExceptionIfSourceNotFoundInMove() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile source = factory.file("tmp/source.txt");
    try {
      source.moveTo(factory.file("tmp/dest.txt"));
      fail("TFileNotFound should have been thrown");
    } catch (TFileNotFoundException e) {
      ensure.that(e.getPath()).eq(TPath.parse("tmp/source.txt"));
    }
  }

  public void testThrowExceptionIfDestinationExistsInMove() throws Exception {
    TFileFactory factory = new TFileFactory(fileSystem());
    TFile source = factory.file("tmp/source.txt");
    source.save("content");
    TFile dest = factory.file("tmp/dest.txt");
    dest.save("another content");
    try {
      source.moveTo(dest);
      fail("TIoException should have been thrown");
    } catch (TIoException e) {
      ensure.that(e.getPath()).eq(TPath.parse("tmp/dest.txt"));
    }
  }

  public void testHaveRegularFileOperation() throws Exception {
    FileSystem fileSystem = fileSystem();
    TFileFactory factory = new TFileFactory(fileSystem);
    String pathString = "tmp/content.txt";
    TFile file = factory.file(pathString);
    String content = "my content";
    file.save(content);
    ensure.that(file.path()).eq(fileSystem.pathString(TPath.parse(pathString)));
    ensure.that(file.length()).eq(content.getBytes().length);
  }

  public void testHaveRegularDirectoryOperation() throws Exception {
    FileSystem fileSystem = fileSystem();
    TFileFactory factory = new TFileFactory(fileSystem);
    String pathString = "tmp/directory";
    final TDirectory directory = factory.dir(pathString);
    ensure.that(directory.exists()).eq(false);
    ensure.that(directory.path()).eq(fileSystem.pathString(TPath.parse(pathString)));
    ensure.code(new CodeBlock() {
      public void execute() throws Exception {
        directory.list().dirs();
      }
    }).throwsException(TDirectoryNotFoundException.class);
    ensure.code(new CodeBlock() {
      public void execute() throws Exception {
        directory.list().files();
      }
    }).throwsException(TDirectoryNotFoundException.class);

    directory.ensureExists();
    ensure.that(directory.list().dirs()).isEmpty();
    ensure.that(directory.list().files()).isEmpty();
  }

  public void testCopyDirectoryAndFile() throws TIoException {
    FileSystem fileSystem = fileSystem();
    TFileFactory factory = new TFileFactory(fileSystem);
    TDirectory source = factory.dir("tmp/source");
    source.file("one.txt").save("oneoneone");
    source.dir("sub").file("two.txt").save("two.txt");
    TDirectory target = factory.dir("tmp/target");
    source.mergeTo(target);
    ensure.that(target.file("one.txt").load()).eq("oneoneone");
    ensure.that(target.dir("sub").file("two.txt").load()).eq("two.txt");
  }

  public void testMoveDirectoryAndFile() throws TIoException {
    FileSystem fileSystem = fileSystem();
    TFileFactory factory = new TFileFactory(fileSystem);
    TDirectory source = factory.dir("tmp/source");
    source.file("one.txt").save("oneoneone");
    source.dir("sub").file("two.txt").save("two.txt");
    TDirectory target = factory.dir("tmp/target");
    source.moveTo(target);
    ensure.that(target.file("one.txt").load()).eq("oneoneone");
    ensure.that(target.dir("sub").file("two.txt").load()).eq("two.txt");
    ensure.that(source.exists()).eq(false);
  }

  public void testHandlingNegativeOneInContentByte() throws TIoException {
    FileSystem fileSystem = fileSystem();
    TFileFactory factory = new TFileFactory(fileSystem);
    TFile file = factory.file("tmp/content.txt");
    file.write(new OutputProcessor() {
      public void process(OutputManager manager) throws IOException {
        manager.outputStream().write(255);
      }
    });
    file.read(new InputProcessor() {
      public void process(InputManager inputManager) throws IOException {
        ensure.that(inputManager.inputStream().read()).eq(255);
      }
    });
  }

}