/// <summary>
/// Downloads the specified test file and verifies its contents.
/// </summary>
private async Task TestFileDownload(TestData.TestFile testFile)
{
var target = Path.GetTempFileName();
try
{
Debug.WriteLine("Temporary local file: " + target);
using (var feedback = new DebugFeedbackChannel("Test"))
{
using (var initializing = feedback.BeginSubOperation("InitializeData"))
await TestData.Current.BringToInitialState(initializing);
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
var filesystem = await client.GetFilesystemSnapshotAsync(feedback);
var file = testFile.TryFind(filesystem);
if (file == null)
Assert.Fail("Could not find expected file to download: " + testFile.Name);
await file.DownloadContentsAsync(target, feedback);
using (var expectedContents = testFile.Open())
using (var contents = File.OpenRead(target))
TestHelper.AssertStreamsAreEqual(expectedContents, contents);
}
}
finally
{
File.Delete(target);
}
}
public async Task Execute_CancelledBeforeFirstRetry_WorksFine()
{
var cts = new CancellationTokenSource();
int executionCount = 0;
try
{
using (var feedback = new DebugFeedbackChannel(""))
await RetryHelper.ExecuteWithRetryAsync(async delegate
{
executionCount++;
await Task.Yield();
cts.Cancel();
throw new Exception("Always a failure.");
}, EverythingInThreesPolicy, feedback, cts.Token);
Assert.Fail("Did not see OperationCanceledException");
}
catch (OperationCanceledException)
{
}
Assert.AreEqual(1, executionCount);
}
public async Task SuccessfulLogin_IsSuccessful()
{
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
using (var connecting = new DebugFeedbackChannel("Test"))
await client.EnsureConnectedAsync(connecting);
}
public async Task Execute_WithAlwaysFailingFunc_WorksFine()
{
using (var feedback = new DebugFeedbackChannel(""))
await RetryHelper.ExecuteWithRetryAsync(async delegate
{
await Task.Yield();
throw new ContractException("Always a failure.");
}, EverythingInThreesPolicy, feedback, CancellationToken.None);
}
public async Task AccountListLoad_DoesNotCauseApocalypse()
{
using (var feedback = new DebugFeedbackChannel("Test"))
{
using (var initializing = feedback.BeginSubOperation("InitializeData"))
await TestData.Current.BringToInitialState(initializing);
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
await client.EnsureConnectedAsync(feedback);
await client.GetContactListSnapshotAsync(feedback);
}
}
public async Task SendFileToContact_SeemsToWork()
{
using (var feedback = new DebugFeedbackChannel("Test"))
{
using (var initializing = feedback.BeginSubOperation("InitializeData"))
await TestData.Current.BringToInitialState(initializing);
using (var sending = feedback.BeginSubOperation("Sending"))
{
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
await client.AddContactAsync(TestData.Current.Email2, sending);
var contactList = await client.GetContactListSnapshotAsync(sending);
Assert.AreEqual(1, contactList.Count);
var account2 = contactList.Single();
var filesystem = await client.GetFilesystemSnapshotAsync(sending);
var file = TestData.SmallFile.Find(filesystem);
await file.SendToContactAsync(account2, sending);
}
using (var receiving = feedback.BeginSubOperation("Receiving"))
{
var client = new MegaClient(TestData.Current.Email2, TestData.Current.Password2);
var filesystem = await client.GetFilesystemSnapshotAsync(receiving);
var file = TestData.SmallFile.Find(filesystem);
Assert.IsNotNull(file);
var target = Path.GetTempFileName();
// Verify contents.
try
{
Debug.WriteLine("Temporary local file: " + target);
await file.DownloadContentsAsync(target, feedback);
using (var expectedContents = TestData.SmallFile.Open())
using (var contents = File.OpenRead(target))
TestHelper.AssertStreamsAreEqual(expectedContents, contents);
}
finally
{
File.Delete(target);
}
}
}
}
public async Task Execute_WithoutRetry_WorksFine()
{
bool executed = false;
using (var feedback = new DebugFeedbackChannel(""))
await RetryHelper.ExecuteWithRetryAsync(async delegate
{
await Task.Yield();
executed = true;
}, EverythingInThreesPolicy, feedback, CancellationToken.None);
Assert.IsTrue(executed);
}
public async Task TestAccountInitialization_IsSuccessful()
{
using (var connecting = new DebugFeedbackChannel("Test"))
{
using (var initializing = connecting.BeginSubOperation("InitializeData"))
{
await TestData.Current.BringToInitialState(initializing);
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
await client.EnsureConnectedAsync(connecting);
}
}
}
public async Task Execute_WithOneRetry_WorksFine()
{
int executionCount = 0;
using (var feedback = new DebugFeedbackChannel(""))
await RetryHelper.ExecuteWithRetryAsync(async delegate
{
await Task.Yield();
if (executionCount++ == 0)
throw new Exception("First time failure.");
}, EverythingInThreesPolicy, feedback, CancellationToken.None);
Assert.AreEqual(2, executionCount);
}
/// <summary>
/// Uploads the specified test file and ensures that it looks like it really did get uploaded.
/// </summary>
private async Task TestFileUpload(TestData.TestFile testFile)
{
using (var feedback = new DebugFeedbackChannel("Test"))
{
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
var filesystem = await client.GetFilesystemSnapshotAsync(feedback);
// Just stick it in the root, do not care about what already exists there.
CloudItem file;
using (var stream = testFile.Open())
file = await filesystem.Files.NewFileAsync(testFile.Name, stream, feedback);
Assert.AreEqual(testFile.Name, file.Name);
Assert.AreEqual(testFile.Size, file.Size);
}
}
public async Task SendFolderToContact_SeemsToWork()
{
using (var feedback = new DebugFeedbackChannel("Test"))
{
using (var initializing = feedback.BeginSubOperation("InitializeData"))
await TestData.Current.BringToInitialState(initializing);
using (var sending = feedback.BeginSubOperation("Sending"))
{
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
await client.AddContactAsync(TestData.Current.Email2, sending);
var contactList = await client.GetContactListSnapshotAsync(sending);
Assert.AreEqual(1, contactList.Count);
var account2 = contactList.Single();
var filesystem = await client.GetFilesystemSnapshotAsync(sending);
var folder = filesystem.Files.Children
.Single(i => i.Type == ItemType.Folder && i.Name == "Folder1");
await folder.SendToContactAsync(account2, sending);
}
using (var receiving = feedback.BeginSubOperation("Receiving"))
{
var client = new MegaClient(TestData.Current.Email2, TestData.Current.Password2);
var filesystem = await client.GetFilesystemSnapshotAsync(receiving);
var file = TestData.SmallFile.Find(filesystem);
Assert.IsNotNull(file);
Assert.IsNotNull(file.Parent);
Assert.AreEqual("Folder1", file.Parent.Name);
}
}
}
public async Task CancelingDownload_SeemsToWork()
{
var target = Path.GetTempFileName();
try
{
Debug.WriteLine("Temporary local file: " + target);
using (var feedback = new DebugFeedbackChannel("Test"))
{
using (var initializing = feedback.BeginSubOperation("InitializeData"))
await TestData.Current.BringToInitialState(initializing);
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
var filesystem = await client.GetFilesystemSnapshotAsync(feedback);
var file = TestData.BigFile.TryFind(filesystem);
if (file == null)
Assert.Fail("Could not find the test file to download.");
CancellationTokenSource cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
await file.DownloadContentsAsync(target, feedback, cts.Token);
}
}
finally
{
File.Delete(target);
}
}
public async Task TransferringFiles_OfVariousSizes_SeemsToWork()
{
var interestingSizes = new List<int>
{
0,
1,
8,
15,
16,
255,
256,
1023,
1024,
};
// Now also add all the chunk sizes and chunk +-1 sizes for a reasonable amount of chunks.
var chunkSizes = Algorithms.MeasureChunks(8 * 1024 * 1024);
foreach (var chunkSize in chunkSizes)
{
interestingSizes.Add(chunkSize - 16);
interestingSizes.Add(chunkSize - 15);
interestingSizes.Add(chunkSize - 1);
interestingSizes.Add(chunkSize);
interestingSizes.Add(chunkSize + 1);
interestingSizes.Add(chunkSize + 15);
interestingSizes.Add(chunkSize + 16);
}
using (var feedback = new DebugFeedbackChannel("Test"))
{
var client = new MegaClient(TestData.Current.Email1, TestData.Current.Password1);
var filesystem = await client.GetFilesystemSnapshotAsync(feedback);
foreach (var size in interestingSizes)
await TestFileUploadAndDownload(size, filesystem, feedback);
}
}
public async Task Execute_ThrowingNonretriableException_IsNotRetries()
{
int executionCount = 0;
try
{
using (var feedback = new DebugFeedbackChannel(""))
await RetryHelper.ExecuteWithRetryAsync(async delegate
{
await Task.Yield();
if (executionCount++ == 0)
throw new InvalidOperationException("Cannot retry this");
}, NothingInThreesPolicy, feedback, CancellationToken.None);
Assert.Fail("Exception with nonretriable failure was not thrown.");
}
catch (InvalidOperationException ex)
{
Assert.AreEqual("Cannot retry this", ex.Message);
}
Assert.AreEqual(1, executionCount);
}
