protected bool HasTransaction(out IFileTransaction transaction)
{
transaction = null;
if (!_UseTransactions) return false;
if (_TxManager != null && _TxManager.CurrentTransaction != null)
{
foreach (var resource in _TxManager.CurrentTransaction.Resources())
{
if (!(resource is FileResourceAdapter)) continue;
transaction = (resource as FileResourceAdapter).Transaction;
return true;
}
if (!_OnlyJoinExisting)
{
transaction = new FileTransaction("Autocreated File Transaction");
_TxManager.CurrentTransaction.Enlist(new FileResourceAdapter(transaction));
return true;
}
}
return false;
}
public void NotUsingTransactionScope_IsNotDistributed_AboveNegated()
{
using (ITransaction tx = new FileTransaction("Not distributed transaction"))
{
Assert.That(System.Transactions.Transaction.Current, Is.Null);
tx.Complete();
}
}
public void CompletedState()
{
using (ITransaction tx = new FileTransaction())
{
Assert.That(tx.State, Is.EqualTo(TransactionState.Active));
tx.Complete();
Assert.That(tx.State, Is.EqualTo(TransactionState.CommittedOrCompleted));
}
}
public void NonExistentDir()
{
using (var t = new FileTransaction())
{
var dir = (t as IDirectoryAdapter);
Assert.IsFalse(dir.Exists("/hahaha"));
Assert.IsFalse(dir.Exists("another_non_existent"));
dir.Create("existing");
Assert.IsTrue(dir.Exists("existing"));
}
// no commit
Assert.IsFalse(Directory.Exists("existing"));
}
public void NoCommit_MeansNoDirectory()
{
var directoryPath = "testing";
Assert.That(Directory.Exists(directoryPath), Is.False);
using (ITransaction tx = new FileTransaction())
{
Directory.Create(directoryPath);
Assert.IsTrue(Directory.Exists(directoryPath));
tx.Dispose();
}
Assert.That(!Directory.Exists(directoryPath));
}
public void WriteAllText()
{
var filepath = _TfPath.Combine("write-text.txt");
using (ITransaction tx = new FileTransaction("Commit TX"))
{
var fa = (IFileAdapter) tx;
fa.WriteAllText(filepath, "Transacted file.");
tx.Complete();
Assert.That(tx.State == TransactionState.CommittedOrCompleted);
}
File.Exists(filepath).Should("exist after the transaction")
.Be.True();
File.ReadAllLines(filepath)
.First().Should()
.Be.EqualTo("Transacted file.");
}
public void NoCommit_MeansNoDirectory()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
string directoryPath = "testing";
Assert.That(Directory.Exists(directoryPath), Is.False);
using (var tx = new FileTransaction())
{
tx.Begin();
(tx as IDirectoryAdapter).Create(directoryPath);
}
Assert.That(!Directory.Exists(directoryPath));
}
public void ExistingDirWithTrailingBackslash()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
// From http://msdn.microsoft.com/en-us/library/aa364419(VS.85).aspx
// An attempt to open a search with a trailing backslash always fails.
// --> So I need to make it succeed.
using (var t = new FileTransaction())
{
t.Begin();
var dir = t as IDirectoryAdapter;
dir.Create("something");
Assert.That(dir.Exists("something"));
Assert.That(dir.Exists("something\\"));
}
}
public void CreatingFolder_InTransaction_AndCommitting_MeansExistsAfter()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
string directoryPath = "testing";
Assert.That(Directory.Exists(directoryPath), Is.False);
using (var tx = new FileTransaction())
{
tx.Begin();
(tx as IDirectoryAdapter).Create(directoryPath);
tx.Commit();
}
Assert.That(Directory.Exists(directoryPath));
Directory.Delete(directoryPath);
}
public void TwoTransactions_SameName_FirstSleeps()
{
var t1_started = new ManualResetEvent(false);
var t2_started = new ManualResetEvent(false);
Exception e = null;
// non transacted thread
var t1 = new Thread(() =>
{
try
{
// modifies the file
using (var fs = File.OpenWrite("abb"))
{
Console.WriteLine("t2 start");
Console.Out.Flush();
t2_started.Set(); // before the transacted thread does
Console.WriteLine("t2 wait for t1 to start");
Console.Out.Flush();
t1_started.WaitOne();
fs.Write(new byte[] { 0x1 }, 0, 1);
fs.Close();
}
}
catch (Exception ee)
{
e = ee;
}
finally
{
Console.WriteLine("t2 finally");
Console.Out.Flush();
t2_started.Set();
}
});
t1.Start();
using (ITransaction t = new FileTransaction())
{
Console.WriteLine("t1 wait for t2 to start");
Console.Out.Flush();
t2_started.WaitOne();
try
{
Console.WriteLine("t1 started");
// the transacted thread should receive ERROR_TRANSACTIONAL_CONFLICT, but it gets permission denied.
using (var fs = ((IFileAdapter)t).Create("abb"))
{
fs.WriteByte(0x2);
}
}
finally
{
Console.WriteLine("t1 finally");
Console.Out.Flush();
t1_started.Set();
}
t.Complete();
}
if (e != null)
{
Console.WriteLine(e);
Assert.Fail(e.Message);
}
}
public void NotUsingTransactionScope_IsNotDistributed_AboveNegated()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
using (var tx = new FileTransaction("Not distributed transaction"))
{
tx.Begin();
Assert.That(tx.IsAmbient, Is.False);
tx.Commit();
}
}
public void CanNotDelete_NonRecursively_NonEmptyDir()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
// 1. create dir and file
string dir = dllPath.CombineAssert("testing");
string file = dir.Combine("file");
File.WriteAllText(file, "hello");
// 2. test it
using (var t = new FileTransaction("Can not delete non-empty directory"))
{
IDirectoryAdapter da = t;
t.Begin();
Assert.That(da.Delete(dir, false),
Is.False,
"Did not delete non-empty dir.");
IFileAdapter fa = t;
fa.Delete(file);
Assert.That(da.Delete(dir, false),
"After deleting the file in the folder, the folder is also deleted.");
t.Commit();
}
}
public void CanCreateDirectory_NLengths_DownInNonExistentDirectory()
{
var directoryPath = "testing/apa/apa2";
Assert.That(Directory.Exists(directoryPath), Is.False);
using (ITransaction t = new FileTransaction())
{
Directory.Create(directoryPath);
t.Complete();
}
Assert.That(Directory.Exists(directoryPath));
Directory.Delete(directoryPath);
}
public void Using_NormalStates()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
using (var tx = new FileTransaction())
{
Assert.That(tx.Status, Is.EqualTo(TransactionStatus.NoTransaction));
tx.Begin();
Assert.That(tx.Status, Is.EqualTo(TransactionStatus.Active));
tx.Commit();
Assert.That(tx.Status, Is.EqualTo(TransactionStatus.Committed));
}
}
public void CanDelete_NonRecursively_EmptyDir()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
// 1. create dir
string dir = dllPath.CombineAssert("testing");
// 2. test it
using (var t = new FileTransaction("Can delete empty directory"))
{
IDirectoryAdapter da = t;
t.Begin();
Assert.That(da.Delete(dir, false), "Successfully deleted.");
t.Commit();
}
}
public void InvalidStateOnCreate_Throws()
{
using (var tx = new FileTransaction())
{
Assert.Throws(typeof (TransactionException), () => (tx as IDirectoryAdapter).Create("lol"),
"The transaction hasn't begun, throws.");
}
}
public void Using_TransactionScope_IsDistributed_AlsoTestingStatusWhenRolledBack()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
using (new TransactionScope())
{
using (var tx = new FileTransaction())
{
tx.Begin();
Assert.That(tx.IsAmbient);
tx.Rollback();
Assert.That(tx.IsRollbackOnlySet);
Assert.That(tx.Status, Is.EqualTo(TransactionStatus.RolledBack));
}
}
}
public void FailingResource_TxStillRolledBack()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
using (var tx = new FileTransaction())
{
tx.Enlist(new R());
tx.Begin();
try
{
try
{
tx.Rollback();
Assert.Fail("Tests is wrong or the transaction doesn't rollback resources.");
}
catch (Exception)
{
}
Assert.That(tx.Status == TransactionStatus.RolledBack);
}
catch (RollbackResourceException rex)
{
// good.
Assert.That(rex.FailedResources[0].First, Is.InstanceOf(typeof (R)));
}
}
}
public void CreatingFolder_InTransaction_AndCommitting_MeansExistsAfter()
{
var directoryPath = "testing";
Assert.That(Directory.Exists(directoryPath), Is.False);
using (ITransaction tx = new FileTransaction())
{
Directory.Create(directoryPath);
tx.Complete();
}
Assert.That(Directory.Exists(directoryPath));
Directory.Delete(directoryPath);
}
public void ExistingDirWithTrailingBackslash()
{
// From http://msdn.microsoft.com/en-us/library/aa364419(VS.85).aspx
// An attempt to open a search with a trailing backslash always fails.
// --> So I need to make it succeed.
using (var t = new FileTransaction())
{
var dir = t as IDirectoryAdapter;
dir.Create("something");
Assert.That(dir.Exists("something"));
Assert.That(dir.Exists("something\\"));
}
}
public void CanCreate_AndFind_Directory_WithinTx()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
using (var tx = new FileTransaction("s"))
{
tx.Begin();
Assert.That((tx as IDirectoryAdapter).Exists("something"), Is.False);
(tx as IDirectoryAdapter).Create("something");
Assert.That((tx as IDirectoryAdapter).Exists("something"));
tx.Rollback();
}
}
public void NonExistentDir()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
using (var t = new FileTransaction())
{
t.Begin();
var dir = (t as IDirectoryAdapter);
Assert.IsFalse(dir.Exists("/hahaha"));
Assert.IsFalse(dir.Exists("another_non_existent"));
dir.Create("existing");
Assert.IsTrue(dir.Exists("existing"));
}
// no commit
Assert.IsFalse(Directory.Exists("existing"));
}
public void CanCreateDirectory_NLengths_DownInNonExistentDirectory()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
string directoryPath = "testing/apa/apa2";
Assert.That(Directory.Exists(directoryPath), Is.False);
using (var t = new FileTransaction())
{
t.Begin();
(t as IDirectoryAdapter).Create(directoryPath);
t.Commit();
}
Assert.That(Directory.Exists(directoryPath));
Directory.Delete(directoryPath);
}
public void CanDelete_Recursively()
{
// 1. Create directory
var pr = _TfPath.Combine("testing");
Directory.Create(pr);
Directory.Create(pr.Combine("one"));
Directory.Create(pr.Combine("two"));
Directory.Create(pr.Combine("three"));
// 2. Write contents
File.WriteAllLines(pr.Combine("one", "fileone"), new[] {"Hello world", "second line"});
File.WriteAllLines(pr.Combine("one", "filetwo"), new[] {"two", "second line"});
File.WriteAllLines(pr.Combine("two", "filethree"), new[] {"three", "second line"});
// 3. test
using (ITransaction t = new FileTransaction())
{
Assert.IsTrue(((IDirectoryAdapter) t).Delete(pr, true));
t.Complete();
}
}
public void CanDelete_Recursively()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
// 1. Create directory
string pr = dllPath.Combine("testing");
Directory.CreateDirectory(pr);
Directory.CreateDirectory(pr.Combine("one"));
Directory.CreateDirectory(pr.Combine("two"));
Directory.CreateDirectory(pr.Combine("three"));
// 2. Write contents
File.WriteAllLines(Exts.Combine(pr, "one").Combine("fileone"), new[] { "Hello world", "second line" });
File.WriteAllLines(Exts.Combine(pr, "one").Combine("filetwo"), new[] { "two", "second line" });
File.WriteAllLines(Exts.Combine(pr, "two").Combine("filethree"), new[] { "three", "second line" });
// 3. test
using (var t = new FileTransaction())
{
t.Begin();
Assert.IsTrue((t as IDirectoryAdapter).Delete(pr, true));
t.Commit();
}
}
public void CannotCommitAfterSettingRollbackOnly()
{
if (Environment.OSVersion.Version.Major < 6)
{
Assert.Ignore("TxF not supported");
return;
}
using (var tx = new FileTransaction())
{
tx.Begin();
tx.SetRollbackOnly();
Assert.Throws(typeof(TransactionException), tx.Commit,
"Should not be able to commit after rollback is set.");
}
}
public void CTorTests()
{
var t = new FileTransaction();
Assert.That(t.Status, Is.EqualTo(TransactionStatus.NoTransaction));
}
public void CanNotDelete_NonRecursively_NonEmptyDir()
{
// 1. create dir and file
var dir = _TfPath.CombineAssert("testing");
var file = dir.Combine("file");
File.WriteAllText(file, "hello");
// 2. test it
using (ITransaction t = new FileTransaction("Can not delete non-empty directory"))
{
Assert.That(Directory.DeleteDirectory(dir, false),
Is.False,
"Did not delete non-empty dir.");
File.Delete(file);
Assert.That(Directory.DeleteDirectory(dir, false),
"After deleting the file in the folder, the folder is also deleted.");
t.Complete();
}
}
public void CanMoveDirectory()
{
string dir1 = dllPath.CombineAssert("a");
string dir2 = dllPath.Combine("b");
Assert.That(Directory.Exists(dir2), Is.False);
Assert.That(File.Exists(dir2), Is.False, "Lingering files should not be allowed to disrupt the testing.");
string aFile = dir1.Combine("file");
File.WriteAllText(aFile, "I should also be moved.");
infosCreated.Add(aFile);
using (var t = new FileTransaction("moving tx"))
{
t.Begin();
(t as IDirectoryAdapter).Move(dir1, dir2);
Assert.IsFalse(Directory.Exists(dir2), "The directory should not yet exist.");
t.Commit();
Assert.That(Directory.Exists(dir2), "Now after committing it should.");
infosCreated.Add(dir2);
Assert.That(File.Exists(dir2.Combine(Path.GetFileName(aFile))), "And so should the file in the directory.");
}
}
public void CanDelete_NonRecursively_EmptyDir()
{
// 1. create dir
var dir = _TfPath.CombineAssert("testing");
// 2. test it
using (ITransaction t = new FileTransaction("Can delete empty directory"))
{
Assert.That(((IDirectoryAdapter) t).Delete(dir, false), "Successfully deleted.");
t.Complete();
}
}
