Пример #1
0
        public async Task NotificationReceivedWhenFileUpdated()
        {
            await client.UploadAsync("abc.txt", new MemoryStream());

            var notificationTask = store.Changes().ForFolder("/")
                                   .Timeout(TimeSpan.FromSeconds(2))
                                   .Take(1).ToTask();

            await client.UpdateMetadataAsync("abc.txt", new RavenJObject { { "MyMetadata", "MyValue" } });

            var fileChange = await notificationTask;

            Assert.Equal("/abc.txt", fileChange.File);
            Assert.Equal(FileChangeAction.Update, fileChange.Action);
        }
        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);
        }