public async Task NotificationReceivedWhenFileAdded()
{
var notificationTask = store.Changes().ForFolder("/")
.Timeout(TimeSpan.FromSeconds(2))
.Take(1).ToTask();
await client.UploadAsync("abc.txt", new MemoryStream());
var fileChange = await notificationTask;
Assert.Equal("/abc.txt", fileChange.File);
Assert.Equal(FileChangeAction.Add, fileChange.Action);
}
private async Task CreateSampleData(IAsyncFilesCommands commands, int startIndex = 1, int count = 2)
{
for (var i = startIndex; i < startIndex + count; i++)
{
await commands.UploadAsync(string.Format("file{0}.bin", i), StringToStream("Secret records / " + i));
}
}
public async Task NotificationIsReceivedWhenConflictIsDetected()
{
var sourceContent = new RandomlyModifiedStream(new RandomStream(1), 0.01);
var destinationContent = new RandomlyModifiedStream(sourceContent, 0.01);
var sourceMetadata = new RavenJObject
{
{ "SomeTest-metadata", "some-value" }
};
var destinationMetadata = new RavenJObject
{
{ "SomeTest-metadata", "should-be-overwritten" }
};
await destinationClient.UploadAsync("abc.txt", destinationContent, destinationMetadata);
await sourceClient.UploadAsync("abc.txt", sourceContent, sourceMetadata);
var notificationTask = destinationStore.Changes()
.ForConflicts()
.OfType <ConflictNotification>()
.Where(x => x.Status == ConflictStatus.Detected)
.Timeout(TimeSpan.FromSeconds(5))
.Take(1)
.ToTask();
await sourceClient.Synchronization.StartAsync("abc.txt", destinationClient);
var conflictDetected = await notificationTask;
Assert.Equal("abc.txt", conflictDetected.FileName);
Assert.Equal(new Uri(sourceStore.Url).Port, new Uri(conflictDetected.SourceServerUrl).Port);
}
private void UploadFilesSynchronously(out IAsyncFilesCommands sourceClient,
out IAsyncFilesCommands destinationClient, string fileName = "test.bin")
{
sourceClient = NewAsyncClient(1);
destinationClient = NewAsyncClient(0);
var sourceContent = new RandomlyModifiedStream(new RandomStream(10, 1), 0.01);
var destinationContent = new RandomlyModifiedStream(new RandomStream(10, 1), 0.01);
destinationClient.UploadAsync(fileName, destinationContent).Wait();
sourceClient.UploadAsync(fileName, sourceContent).Wait();
}
private static async Task RunMetadataSynchronization(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("metadata-test")), new RavenJObject { { "Sample-Header", "destination" } });
if (action != null)
{
action();
}
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("metadata-test")), new RavenJObject { { "Sample-Header", "source" } });
var report = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Null(report.Exception);
Assert.Equal(SynchronizationType.MetadataUpdate, report.Type);
}
private static async Task RunDeleteSynchronization(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("delete-test")));
if (action != null)
{
action();
}
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("delete-test")));
await sourceClient.DeleteAsync("test");
var report = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Null(report.Exception);
Assert.Equal(SynchronizationType.Delete, report.Type);
}
private static async Task <string> RunContentSynchronization(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("destination")));
if (action != null)
{
action();
}
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("source")));
var report = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Null(report.Exception);
Assert.Equal(SynchronizationType.ContentUpdate, report.Type);
var stream = await destinationClient.DownloadAsync("test");
return(StreamToString(stream));
}
private static async Task <string> ExecuteRawSynchronizationRequest(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("destination")));
if (action != null)
{
action();
}
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("source")));
var sourceStream = new MemoryStream();
(await sourceClient.DownloadAsync("test")).CopyTo(sourceStream);
var metadata = await sourceClient.GetMetadataForAsync("test");
var request = new SynchronizationMultipartRequest(destinationClient.Synchronization, new ServerInfo()
{
FileSystemUrl = sourceClient.UrlFor(),
Id = sourceClient.GetServerIdAsync().Result
}, "test", metadata, sourceStream, new[]
{
new RdcNeed()
{
BlockLength = 6,
BlockType = RdcNeedType.Source,
FileOffset = 0
}
});
var synchronizationReport = await request.PushChangesAsync(CancellationToken.None);
Assert.Null(synchronizationReport.Exception);
var stream = await destinationClient.DownloadAsync("test");
return(StreamToString(stream));
}
private static async Task<string> ExecuteRawSynchronizationRequest(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("destination")));
if (action != null)
action();
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("source")));
var sourceStream = new MemoryStream();
(await sourceClient.DownloadAsync("test")).CopyTo(sourceStream);
var metadata = await sourceClient.GetMetadataForAsync("test");
var request = new SynchronizationMultipartRequest(destinationClient.Synchronization, new ServerInfo()
{
FileSystemUrl = sourceClient.UrlFor(),
Id = sourceClient.GetServerIdAsync().Result
}, "test", metadata, sourceStream, new[]
{
new RdcNeed()
{
BlockLength = 6,
BlockType = RdcNeedType.Source,
FileOffset = 0
}
});
var synchronizationReport = await request.PushChangesAsync(CancellationToken.None);
Assert.Null(synchronizationReport.Exception);
var stream = await destinationClient.DownloadAsync("test");
return StreamToString(stream);
}
private void UploadFilesSynchronously(out IAsyncFilesCommands sourceClient,
out IAsyncFilesCommands destinationClient, string fileName = "test.bin")
{
sourceClient = NewAsyncClient(1);
destinationClient = NewAsyncClient(0);
var sourceContent = new RandomlyModifiedStream(new RandomStream(10, 1), 0.01);
var destinationContent = new RandomlyModifiedStream(new RandomStream(10, 1), 0.01);
destinationClient.UploadAsync(fileName, destinationContent).Wait();
sourceClient.UploadAsync(fileName, sourceContent).Wait();
}
private async Task CreateSampleData(IAsyncFilesCommands commands, int startIndex = 1, int count = 2)
{
for (var i = startIndex; i < startIndex + count; i++)
{
await commands.UploadAsync(string.Format("file{0}.bin", i), StringToStream("Secret records / " + i));
}
}
public async Task NotificationsAreReceivedOnSourceWhenSynchronizationsAreStartedAndFinished()
{
// content update
await sourceClient.UploadAsync("test.bin", new MemoryStream(new byte[] { 1, 2, 3 }));
var notificationTask = sourceStore.Changes().ForSynchronization()
.Where(s => s.Direction == SynchronizationDirection.Outgoing)
.Timeout(TimeSpan.FromSeconds(20)).Take(2).ToArray().
ToTask();
var report = await sourceClient.Synchronization.StartAsync("test.bin", destinationClient);
Assert.Null(report.Exception);
var synchronizationUpdates = await notificationTask;
Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action);
Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[0].FileName);
Assert.Equal(SynchronizationType.ContentUpdate, synchronizationUpdates[0].Type);
Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action);
Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[1].FileName);
Assert.Equal(SynchronizationType.ContentUpdate, synchronizationUpdates[1].Type);
// metadata update
await sourceClient.UpdateMetadataAsync("test.bin", new RavenJObject { { "key", "value" } });
notificationTask = sourceStore.Changes().ForSynchronization()
.Where(s => s.Direction == SynchronizationDirection.Outgoing)
.Timeout(TimeSpan.FromSeconds(20))
.Take(2).ToArray()
.ToTask();
report = await sourceClient.Synchronization.StartAsync("test.bin", destinationClient);
Assert.Null(report.Exception);
synchronizationUpdates = await notificationTask;
Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action);
Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[0].FileName);
Assert.Equal(SynchronizationType.MetadataUpdate, synchronizationUpdates[0].Type);
Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action);
Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[1].FileName);
Assert.Equal(SynchronizationType.MetadataUpdate, synchronizationUpdates[1].Type);
// rename update
await sourceClient.RenameAsync("test.bin", "rename.bin");
notificationTask = sourceStore.Changes().ForSynchronization()
.Where(s => s.Direction == SynchronizationDirection.Outgoing)
.Timeout(TimeSpan.FromSeconds(20))
.Take(2).ToArray()
.ToTask();
report = await sourceClient.Synchronization.StartAsync("test.bin", destinationClient);
Assert.Null(report.Exception);
synchronizationUpdates = await notificationTask;
Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action);
Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[0].FileName);
Assert.Equal(SynchronizationType.Rename, synchronizationUpdates[0].Type);
Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action);
Assert.Equal(FileHeader.Canonize("test.bin"), synchronizationUpdates[1].FileName);
Assert.Equal(SynchronizationType.Rename, synchronizationUpdates[1].Type);
// delete update
await sourceClient.DeleteAsync("rename.bin");
notificationTask = sourceStore.Changes().ForSynchronization()
.Where(s => s.Direction == SynchronizationDirection.Outgoing)
.Timeout(TimeSpan.FromSeconds(20))
.Take(2).ToArray()
.ToTask();
report = await sourceClient.Synchronization.StartAsync("rename.bin", destinationClient);
Assert.Null(report.Exception);
synchronizationUpdates = await notificationTask;
Assert.Equal(SynchronizationAction.Start, synchronizationUpdates[0].Action);
Assert.Equal(FileHeader.Canonize("rename.bin"), synchronizationUpdates[0].FileName);
Assert.Equal(SynchronizationType.Delete, synchronizationUpdates[0].Type);
Assert.Equal(SynchronizationAction.Finish, synchronizationUpdates[1].Action);
Assert.Equal(FileHeader.Canonize("rename.bin"), synchronizationUpdates[1].FileName);
Assert.Equal(SynchronizationType.Delete, synchronizationUpdates[1].Type);
}
private static async Task RunDeleteSynchronization(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("delete-test")));
if (action != null)
action();
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("delete-test")));
await sourceClient.DeleteAsync("test");
var report = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Null(report.Exception);
Assert.Equal(SynchronizationType.Delete, report.Type);
}
private static async Task RunMetadataSynchronization(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("metadata-test")), new RavenJObject { { "Sample-Header", "destination" } });
if (action != null)
action();
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("metadata-test")), new RavenJObject { { "Sample-Header", "source" } });
var report = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Null(report.Exception);
Assert.Equal(SynchronizationType.MetadataUpdate, report.Type);
}
private static async Task<string> RunContentSynchronization(IAsyncFilesCommands sourceClient, IAsyncFilesCommands destinationClient, Action action = null)
{
await destinationClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("destination")));
if (action != null)
action();
await sourceClient.UploadAsync("test", new MemoryStream(Encoding.UTF8.GetBytes("source")));
var report = await sourceClient.Synchronization.StartAsync("test", destinationClient);
Assert.Null(report.Exception);
Assert.Equal(SynchronizationType.ContentUpdate, report.Type);
var stream = await destinationClient.DownloadAsync("test");
return StreamToString(stream);
}