public virtual void TestCreateFileOverExistingFileNoOverwrite()
{
Describe("Verify overwriting an existing file fails");
Path path = Path("testCreateFileOverExistingFileNoOverwrite");
byte[] data = ContractTestUtils.Dataset(256, 'a', 'z');
ContractTestUtils.WriteDataset(GetFileSystem(), path, data, data.Length, 1024, false
);
byte[] data2 = ContractTestUtils.Dataset(10 * 1024, 'A', 'Z');
try
{
ContractTestUtils.WriteDataset(GetFileSystem(), path, data2, data2.Length, 1024,
false);
NUnit.Framework.Assert.Fail("writing without overwrite unexpectedly succeeded");
}
catch (FileAlreadyExistsException expected)
{
//expected
HandleExpectedException(expected);
}
catch (IOException relaxed)
{
HandleRelaxedException("Creating a file over a file with overwrite==false", "FileAlreadyExistsException"
, relaxed);
}
}
public virtual void TestOverwriteEmptyDirectory()
{
Describe("verify trying to create a file over an empty dir fails");
Path path = Path("testOverwriteEmptyDirectory");
Mkdirs(path);
AssertIsDirectory(path);
byte[] data = ContractTestUtils.Dataset(256, 'a', 'z');
try
{
ContractTestUtils.WriteDataset(GetFileSystem(), path, data, data.Length, 1024, true
);
AssertIsDirectory(path);
NUnit.Framework.Assert.Fail("write of file over empty dir succeeded");
}
catch (FileAlreadyExistsException expected)
{
//expected
HandleExpectedException(expected);
}
catch (FileNotFoundException e)
{
HandleRelaxedException("overwriting a dir with a file ", "FileAlreadyExistsException"
, e);
}
catch (IOException e)
{
HandleRelaxedException("overwriting a dir with a file ", "FileAlreadyExistsException"
, e);
}
AssertIsDirectory(path);
}
public virtual void TestRenameFileNonexistentDir()
{
Describe("rename a file into a new file in the same directory");
Path renameSrc = Path("testRenameSrc");
Path renameTarget = Path("subdir/testRenameTarget");
byte[] data = ContractTestUtils.Dataset(256, 'a', 'z');
ContractTestUtils.WriteDataset(GetFileSystem(), renameSrc, data, data.Length, 1024
* 1024, false);
bool renameCreatesDestDirs = IsSupported(RenameCreatesDestDirs);
try
{
bool rename = Rename(renameSrc, renameTarget);
if (renameCreatesDestDirs)
{
Assert.True(rename);
ContractTestUtils.VerifyFileContents(GetFileSystem(), renameTarget, data);
}
else
{
NUnit.Framework.Assert.IsFalse(rename);
ContractTestUtils.VerifyFileContents(GetFileSystem(), renameSrc, data);
}
}
catch (FileNotFoundException)
{
// allowed unless that rename flag is set
NUnit.Framework.Assert.IsFalse(renameCreatesDestDirs);
}
}
public virtual void TestRenameDirIntoExistingDir()
{
Describe("Verify renaming a dir into an existing dir puts it underneath" + " and leaves existing files alone"
);
FileSystem fs = GetFileSystem();
string sourceSubdir = "source";
Path srcDir = Path(sourceSubdir);
Path srcFilePath = new Path(srcDir, "source-256.txt");
byte[] srcDataset = ContractTestUtils.Dataset(256, 'a', 'z');
ContractTestUtils.WriteDataset(fs, srcFilePath, srcDataset, srcDataset.Length, 1024
, false);
Path destDir = Path("dest");
Path destFilePath = new Path(destDir, "dest-512.txt");
byte[] destDateset = ContractTestUtils.Dataset(512, 'A', 'Z');
ContractTestUtils.WriteDataset(fs, destFilePath, destDateset, destDateset.Length,
1024, false);
AssertIsFile(destFilePath);
bool rename = Rename(srcDir, destDir);
Path renamedSrc = new Path(destDir, sourceSubdir);
AssertIsFile(destFilePath);
AssertIsDirectory(renamedSrc);
ContractTestUtils.VerifyFileContents(fs, destFilePath, destDateset);
Assert.True("rename returned false though the contents were copied"
, rename);
}
public virtual void TestOverwriteNonEmptyDirectory()
{
Describe("verify trying to create a file over a non-empty dir fails");
Path path = Path("testOverwriteNonEmptyDirectory");
Mkdirs(path);
try
{
AssertIsDirectory(path);
}
catch (Exception failure)
{
if (IsSupported(IsBlobstore))
{
// file/directory hack surfaces here
throw Extensions.InitCause(new AssumptionViolatedException(failure.ToString
()), failure);
}
// else: rethrow
throw;
}
Path child = new Path(path, "child");
ContractTestUtils.WriteTextFile(GetFileSystem(), child, "child file", true);
byte[] data = ContractTestUtils.Dataset(256, 'a', 'z');
try
{
ContractTestUtils.WriteDataset(GetFileSystem(), path, data, data.Length, 1024, true
);
FileStatus status = GetFileSystem().GetFileStatus(path);
bool isDir = status.IsDirectory();
if (!isDir && IsSupported(IsBlobstore))
{
// object store: downgrade to a skip so that the failure is visible
// in test results
ContractTestUtils.Skip("Object store allows a file to overwrite a directory");
}
NUnit.Framework.Assert.Fail("write of file over dir succeeded");
}
catch (FileAlreadyExistsException expected)
{
//expected
HandleExpectedException(expected);
}
catch (FileNotFoundException e)
{
HandleRelaxedException("overwriting a dir with a file ", "FileAlreadyExistsException"
, e);
}
catch (IOException e)
{
HandleRelaxedException("overwriting a dir with a file ", "FileAlreadyExistsException"
, e);
}
AssertIsDirectory(path);
AssertIsFile(child);
}
public virtual void TestCreateNewFile()
{
Describe("Foundational 'create a file' test");
Path path = Path("testCreateNewFile");
byte[] data = ContractTestUtils.Dataset(256, 'a', 'z');
ContractTestUtils.WriteDataset(GetFileSystem(), path, data, data.Length, 1024 * 1024
, false);
ContractTestUtils.VerifyFileContents(GetFileSystem(), path, data);
}
public virtual void TestOverwriteExistingFile()
{
Describe("Overwrite an existing file and verify the new data is there");
Path path = Path("testOverwriteExistingFile");
byte[] data = ContractTestUtils.Dataset(256, 'a', 'z');
ContractTestUtils.WriteDataset(GetFileSystem(), path, data, data.Length, 1024, false
);
ContractTestUtils.VerifyFileContents(GetFileSystem(), path, data);
byte[] data2 = ContractTestUtils.Dataset(10 * 1024, 'A', 'Z');
ContractTestUtils.WriteDataset(GetFileSystem(), path, data2, data2.Length, 1024,
true);
ContractTestUtils.VerifyFileContents(GetFileSystem(), path, data2);
}
public virtual void TestRenameFileOverExistingFile()
{
Describe("Verify renaming a file onto an existing file matches expectations");
Path srcFile = Path("source-256.txt");
byte[] srcData = ContractTestUtils.Dataset(256, 'a', 'z');
ContractTestUtils.WriteDataset(GetFileSystem(), srcFile, srcData, srcData.Length,
1024, false);
Path destFile = Path("dest-512.txt");
byte[] destData = ContractTestUtils.Dataset(512, 'A', 'Z');
ContractTestUtils.WriteDataset(GetFileSystem(), destFile, destData, destData.Length
, 1024, false);
AssertIsFile(destFile);
bool renameOverwritesDest = IsSupported(RenameOverwritesDest);
bool renameReturnsFalseOnRenameDestExists = !IsSupported(RenameReturnsFalseIfDestExists
);
bool destUnchanged = true;
try
{
bool renamed = Rename(srcFile, destFile);
if (renameOverwritesDest)
{
// the filesystem supports rename(file, file2) by overwriting file2
Assert.True("Rename returned false", renamed);
destUnchanged = false;
}
else
{
// rename is rejected by returning 'false' or throwing an exception
if (renamed && !renameReturnsFalseOnRenameDestExists)
{
//expected an exception
string destDirLS = GenerateAndLogErrorListing(srcFile, destFile);
GetLog().Error("dest dir {}", destDirLS);
NUnit.Framework.Assert.Fail("expected rename(" + srcFile + ", " + destFile + " ) to fail,"
+ " but got success and destination of " + destDirLS);
}
}
}
catch (FileAlreadyExistsException e)
{
HandleExpectedException(e);
}
// verify that the destination file is as expected based on the expected
// outcome
ContractTestUtils.VerifyFileContents(GetFileSystem(), destFile, destUnchanged ? destData
: srcData);
}
public virtual void TestRenameNewFileSameDir()
{
Describe("rename a file into a new file in the same directory");
Path renameSrc = Path("rename_src");
Path renameTarget = Path("rename_dest");
byte[] data = ContractTestUtils.Dataset(256, 'a', 'z');
ContractTestUtils.WriteDataset(GetFileSystem(), renameSrc, data, data.Length, 1024
* 1024, false);
bool rename = Rename(renameSrc, renameTarget);
Assert.True("rename(" + renameSrc + ", " + renameTarget + ") returned false"
, rename);
ContractTestUtils.AssertListStatusFinds(GetFileSystem(), renameTarget.GetParent()
, renameTarget);
ContractTestUtils.VerifyFileContents(GetFileSystem(), renameTarget, data);
}
