public void CanCompareTwoVersionsOfAFileWithADiffOfTwoHunks(int contextLines, int interhunkLines)
{
var compareOptions = new CompareOptions
{
ContextLines = contextLines,
InterhunkLines = interhunkLines,
Similarity = SimilarityOptions.None,
};
using (var repo = new Repository(StandardTestRepoPath))
{
Tree rootCommitTree = repo.Lookup <Commit>("f8d44d7").Tree;
Tree mergedCommitTree = repo.Lookup <Commit>("7252fe2").Tree;
var changes = repo.Diff.Compare <TreeChanges>(rootCommitTree, mergedCommitTree, compareOptions: compareOptions);
Assert.Equal(3, changes.Count());
Assert.Equal(1, changes.Modified.Count());
Assert.Equal(1, changes.Deleted.Count());
Assert.Equal(1, changes.Added.Count());
Assert.Equal(Mode.Nonexistent, changes["my-name-does-not-feel-right.txt"].Mode);
var patch = repo.Diff.Compare <Patch>(rootCommitTree, mergedCommitTree, compareOptions: compareOptions);
ContentChanges contentChanges = patch["numbers.txt"];
Assert.Equal(3, contentChanges.LinesAdded);
Assert.Equal(1, contentChanges.LinesDeleted);
Assert.Equal(Expected("f8d44d7...7252fe2/numbers.txt-{0}-{1}.diff", contextLines, interhunkLines),
contentChanges.Patch);
Assert.Equal(Expected("f8d44d7...7252fe2/full-{0}-{1}.diff", contextLines, interhunkLines),
patch);
}
}
public void DiffSetsTheAddedAndDeletedLinesCorrectly()
{
var path = SandboxStandardTestRepoGitDir();
using (var repo = new Repository(path))
{
var oldContent =
@"1
2
3
4";
var newContent =
@"1
2
3
5";
var oldBlob = repo.ObjectDatabase.CreateBlob(new MemoryStream(Encoding.UTF8.GetBytes(oldContent)));
var newBlob = repo.ObjectDatabase.CreateBlob(new MemoryStream(Encoding.UTF8.GetBytes(newContent)));
ContentChanges changes = repo.Diff.Compare(oldBlob, newBlob);
Assert.Single(changes.AddedLines);
Assert.Single(changes.DeletedLines);
Assert.Equal("4", changes.DeletedLines.First().Content);
Assert.Equal("5", changes.AddedLines.First().Content);
Assert.Equal(4, changes.DeletedLines.First().LineNumber);
Assert.Equal(4, changes.AddedLines.First().LineNumber);
}
}
public void CanCompareTwoVersionsOfAFileWithATrailingNewlineDeletion(int contextLines, int expectedPatchLength)
{
using (var repo = new Repository(StandardTestRepoPath))
{
Tree rootCommitTree = repo.Lookup <Commit>("f8d44d7").Tree;
Tree commitTreeWithUpdatedFile = repo.Lookup <Commit>("ec9e401").Tree;
var changes = repo.Diff.Compare <TreeChanges>(rootCommitTree, commitTreeWithUpdatedFile);
Assert.Equal(1, changes.Count());
Assert.Equal(1, changes.Modified.Count());
var patch = repo.Diff.Compare <Patch>(rootCommitTree, commitTreeWithUpdatedFile,
compareOptions: new CompareOptions {
ContextLines = contextLines
});
Assert.Equal(expectedPatchLength, patch.Content.Length);
ContentChanges contentChanges = patch["numbers.txt"];
Assert.Equal(2, contentChanges.LinesAdded);
Assert.Equal(1, contentChanges.LinesDeleted);
Assert.Equal(expectedPatchLength, contentChanges.Patch.Length);
}
}
private ObservableHandler RunQueue(Mock <ISession> session, Mock <IMetaDataStorage> storage)
{
var manager = new SyncEventManager();
var observer = new ObservableHandler();
manager.AddEventHandler(observer);
SingleStepEventQueue queue = new SingleStepEventQueue(manager);
var changes = new ContentChanges(session.Object, storage.Object, queue, this.maxNumberOfContentChanges, this.isPropertyChangesSupported);
manager.AddEventHandler(changes);
var transformer = new ContentChangeEventTransformer(queue, storage.Object);
manager.AddEventHandler(transformer);
var accumulator = new ContentChangeEventAccumulator(session.Object, queue);
manager.AddEventHandler(accumulator);
queue.RunStartSyncEvent();
return(observer);
}
public Task <CodeOwnerConfig> GetCodeOwnerConfigFromChanges(ContentChanges changes)
{
var result = new StringBuilder();
using (var reader = new StringReader(changes.Patch))
{
string line;
while ((line = reader.ReadLine()) != null)
{
if (line.StartsWith("@"))
{
continue;
}
if (line.StartsWith("+"))
{
result.AppendLine(line.Substring(1));
}
else if (line.StartsWith("-"))
{
result.AppendLine(line.Substring(1));
}
}
}
return(_parser.ParserConfig(result.ToString()));
}
public void IgnoresWrongEvent()
{
var storage = new Mock <IMetaDataStorage>();
var queue = new Mock <ISyncEventQueue>();
var session = new Mock <ISession>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
var startSyncEvent = new Mock <ISyncEvent>().Object;
Assert.IsFalse(changes.Handle(startSyncEvent));
}
public void ComparingTwoNullBlobsReturnsAnEmptyContentChanges()
{
using (var repo = new Repository(StandardTestRepoPath))
{
ContentChanges changes = repo.Diff.Compare((Blob)null, (Blob)null);
Assert.False(changes.IsBinaryComparison);
Assert.Equal(0, changes.LinesAdded);
Assert.Equal(0, changes.LinesDeleted);
}
}
public void ComparingABlobAgainstItselfReturnsNoDifference()
{
using (var repo = new Repository(StandardTestRepoPath))
{
Blob blob = repo.Head.Tip.Tree.Blobs.First();
ContentChanges changes = repo.Diff.Compare(blob, blob);
Assert.Equal(0, changes.LinesAdded);
Assert.Equal(0, changes.LinesDeleted);
Assert.Equal(string.Empty, changes.Patch);
}
}
public void RetrunFalseOnError()
{
// TODO: this might not be the best behavior, this test verifies the current implementation not the desired one
var storage = new Mock <IMetaDataStorage>();
var queue = new Mock <ISyncEventQueue>();
var session = new Mock <ISession>();
session.Setup(x => x.Binding).Throws(new Exception("SOME EXCEPTION"));
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
var wrongEvent = new Mock <ISyncEvent>().Object;
Assert.IsFalse(changes.Handle(wrongEvent));
}
public void ComparingABlobAgainstItselfReturnsNoDifference()
{
using (var repo = new Repository(StandardTestRepoPath))
{
var blob = repo.Lookup <Blob>("7909961");
ContentChanges changes = repo.Diff.Compare(blob, blob);
Assert.Equal(0, changes.LinesAdded);
Assert.Equal(0, changes.LinesDeleted);
Assert.Equal(string.Empty, changes.Patch);
}
}
public void IgnoreDuplicatedContentChangesEventTestDeleted()
{
var queue = new Mock <ISyncEventQueue>();
Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();
Mock <ISession> session = MockSessionUtil.GetSessionMockReturning3Changesin2Batches(DotCMIS.Enums.ChangeType.Deleted, true);
var startSyncEvent = new StartNextSyncEvent(false);
var changes = new ContentChanges(session.Object, storage.Object, queue.Object, this.maxNumberOfContentChanges, this.isPropertyChangesSupported);
Assert.IsTrue(changes.Handle(startSyncEvent));
queue.Verify(foo => foo.AddEvent(It.IsAny <ContentChangeEvent>()), Times.Exactly(3));
}
public void HandleStartSyncEventOnNoRemoteChange()
{
var startSyncEvent = new StartNextSyncEvent(false);
var session = new Mock <ISession>();
session.SetupSessionDefaultValues();
session.Setup(s => s.Binding.GetRepositoryService().GetRepositoryInfo(this.repoId, null).LatestChangeLogToken).Returns(this.changeLogToken);
var storage = new Mock <IMetaDataStorage>();
storage.Setup(db => db.ChangeLogToken).Returns(this.changeLogToken);
var queue = new Mock <ISyncEventQueue>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsTrue(changes.Handle(startSyncEvent));
}
public void CanCompareATextualBlobAgainstABinaryBlob()
{
using (var repo = new Repository(StandardTestRepoPath))
{
Blob binBlob = CreateBinaryBlob(repo);
Blob blob = repo.Head.Tip.Tree.Blobs.First();
ContentChanges changes = repo.Diff.Compare(blob, binBlob);
Assert.True(changes.IsBinaryComparison);
Assert.Equal(0, changes.LinesAdded);
Assert.Equal(0, changes.LinesDeleted);
}
}
public void ExecuteCrawlSyncOnNoLocalTokenAvailable()
{
var startSyncEvent = new StartNextSyncEvent(false);
var session = new Mock <ISession>();
session.SetupSessionDefaultValues();
session.Setup(s => s.Binding.GetRepositoryService().GetRepositoryInfo(this.repoId, null).LatestChangeLogToken).Returns(this.changeLogToken);
var storage = new Mock <IMetaDataStorage>();
storage.Setup(db => db.ChangeLogToken).Returns((string)null);
var queue = new Mock <ISyncEventQueue>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsTrue(changes.Handle(startSyncEvent));
queue.Verify(q => q.AddEvent(It.Is <StartNextSyncEvent>(e => e.FullSyncRequested == true)), Times.Once());
}
public void HandleFullSyncCompletedEvent()
{
var startSyncEvent = new StartNextSyncEvent(false);
startSyncEvent.LastTokenOnServer = this.changeLogToken;
var completedEvent = new FullSyncCompletedEvent(startSyncEvent);
var storage = new Mock <IMetaDataStorage>();
storage.SetupProperty(db => db.ChangeLogToken);
var queue = new Mock <ISyncEventQueue>();
var session = new Mock <ISession>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsFalse(changes.Handle(completedEvent));
storage.VerifySet(db => db.ChangeLogToken = this.changeLogToken);
Assert.AreEqual(this.changeLogToken, storage.Object.ChangeLogToken);
}
public void CanCompareATextualBlobAgainstABinaryBlob()
{
string path = CloneStandardTestRepo();
using (var repo = new Repository(path))
{
Blob binBlob = CreateBinaryBlob(repo);
var blob = repo.Lookup <Blob>("7909961");
ContentChanges changes = repo.Diff.Compare(blob, binBlob);
Assert.True(changes.IsBinaryComparison);
Assert.Equal(0, changes.LinesAdded);
Assert.Equal(0, changes.LinesDeleted);
}
}
public void ComparingBlobsWithNoSpacesAndIndentHeuristicOptionMakesADifference()
{
var path = SandboxStandardTestRepoGitDir();
using (var repo = new Repository(path))
{
// Based on test diff indent heuristic from:
// https://github.com/git/git/blob/433860f3d0beb0c6f205290bd16cda413148f098/t/t4061-diff-indent.sh#L17
var oldContent =
@" 1
2
a
b
3
4" ;
var newContent =
@" 1
2
a
b
a
b
3
4" ;
var oldBlob = repo.ObjectDatabase.CreateBlob(new MemoryStream(Encoding.UTF8.GetBytes(oldContent)));
var newBlob = repo.ObjectDatabase.CreateBlob(new MemoryStream(Encoding.UTF8.GetBytes(newContent)));
var noIndentHeuristicOption = new CompareOptions {
IndentHeuristic = false
};
var indentHeuristicOption = new CompareOptions {
IndentHeuristic = true
};
ContentChanges changes0 = repo.Diff.Compare(oldBlob, newBlob, noIndentHeuristicOption);
ContentChanges changes1 = repo.Diff.Compare(oldBlob, newBlob, indentHeuristicOption);
Assert.NotEqual(changes0.Patch, changes1.Patch);
Assert.Equal(CanonicalChangedLines(changes0), CanonicalChangedLines(changes1));
}
}
public void CanCompareABlobAgainstANullBlob()
{
using (var repo = new Repository(StandardTestRepoPath))
{
var blob = repo.Lookup <Blob>("7909961");
ContentChanges changes = repo.Diff.Compare(null, blob);
Assert.NotEqual(0, changes.LinesAdded);
Assert.Equal(0, changes.LinesDeleted);
Assert.NotEqual(string.Empty, changes.Patch);
changes = repo.Diff.Compare(blob, null);
Assert.Equal(0, changes.LinesAdded);
Assert.NotEqual(0, changes.LinesDeleted);
Assert.NotEqual(string.Empty, changes.Patch);
}
}
public void CanCompareABlobAgainstANullBlob()
{
using (var repo = new Repository(StandardTestRepoPath))
{
Blob blob = repo.Head.Tip.Tree.Blobs.First();
ContentChanges changes = repo.Diff.Compare(null, blob);
Assert.NotEqual(0, changes.LinesAdded);
Assert.Equal(0, changes.LinesDeleted);
Assert.NotEqual(string.Empty, changes.Patch);
changes = repo.Diff.Compare(blob, null);
Assert.Equal(0, changes.LinesAdded);
Assert.NotEqual(0, changes.LinesDeleted);
Assert.NotEqual(string.Empty, changes.Patch);
}
}
public void IgnoreCrawlSyncEvent()
{
var start = new StartNextSyncEvent(true);
var repositoryService = new Mock <IRepositoryService>();
repositoryService.Setup(r => r.GetRepositoryInfos(null)).Returns((IList <IRepositoryInfo>)null);
repositoryService.Setup(r => r.GetRepositoryInfo(It.IsAny <string>(), It.IsAny <IExtensionsData>()).LatestChangeLogToken).Returns(this.latestChangeLogToken);
var session = new Mock <ISession>();
session.Setup(s => s.Binding.GetRepositoryService()).Returns(repositoryService.Object);
session.Setup(s => s.RepositoryInfo.Id).Returns(this.repoId);
var storage = new Mock <IMetaDataStorage>();
storage.Setup(db => db.ChangeLogToken).Returns(this.changeLogToken);
var queue = new Mock <ISyncEventQueue>();
var changes = new ContentChanges(session.Object, storage.Object, queue.Object);
Assert.IsFalse(changes.Handle(start));
Assert.IsNull(start.LastTokenOnServer);
}
public void GivesCorrectContentChangeEvent()
{
ContentChangeEvent contentChangeEvent = null;
var queue = new Mock <ISyncEventQueue>();
queue.Setup(q => q.AddEvent(It.IsAny <ContentChangeEvent>())).Callback((ISyncEvent f) => {
contentChangeEvent = f as ContentChangeEvent;
});
string id = "myId";
Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();
var session = MockSessionUtil.PrepareSessionMockForSingleChange(DotCMIS.Enums.ChangeType.Created, id);
var changes = new ContentChanges(session.Object, storage.Object, queue.Object, this.maxNumberOfContentChanges, this.isPropertyChangesSupported);
var startSyncEvent = new StartNextSyncEvent(false);
Assert.IsTrue(changes.Handle(startSyncEvent));
queue.Verify(foo => foo.AddEvent(It.IsAny <ContentChangeEvent>()), Times.Once());
Assert.That(contentChangeEvent.Type, Is.EqualTo(DotCMIS.Enums.ChangeType.Created));
Assert.That(contentChangeEvent.ObjectId, Is.EqualTo(id));
}
public void CanCompareTwoVersionsOfABlobWithADiffOfTwoHunks()
{
var path = SandboxStandardTestRepoGitDir();
using (var repo = new Repository(path))
{
var oldblob = repo.Lookup <Blob>("7909961");
var newblob = repo.Lookup <Blob>("4e935b7");
ContentChanges changes = repo.Diff.Compare(oldblob, newblob);
Assert.False(changes.IsBinaryComparison);
Assert.Equal(3, changes.LinesAdded);
Assert.Equal(1, changes.LinesDeleted);
var expected = new StringBuilder()
.Append("@@ -1,4 +1,5 @@\n")
.Append(" 1\n")
.Append("+2\n")
.Append(" 3\n")
.Append(" 4\n")
.Append(" 5\n")
.Append("@@ -8,8 +9,9 @@\n")
.Append(" 8\n")
.Append(" 9\n")
.Append(" 10\n")
.Append("-12\n")
.Append("+11\n")
.Append(" 12\n")
.Append(" 13\n")
.Append(" 14\n")
.Append(" 15\n")
.Append("+16\n");
Assert.Equal(expected.ToString(), changes.Patch);
}
}
public void ComparingBlobsWithNoSpacesIndentHeuristicOptionMakesNoDifference()
{
var path = SandboxStandardTestRepoGitDir();
using (var repo = new Repository(path))
{
var oldContent =
@" 1
2
a
b
3
4" ;
var newContent =
@" 1
2
a
b
a
b
3
4" ;
var oldBlob = repo.ObjectDatabase.CreateBlob(new MemoryStream(Encoding.UTF8.GetBytes(oldContent)));
var newBlob = repo.ObjectDatabase.CreateBlob(new MemoryStream(Encoding.UTF8.GetBytes(newContent)));
var noIndentHeuristicOption = new CompareOptions {
IndentHeuristic = false
};
var indentHeuristicOption = new CompareOptions {
IndentHeuristic = true
};
ContentChanges changes0 = repo.Diff.Compare(oldBlob, newBlob, noIndentHeuristicOption);
ContentChanges changes1 = repo.Diff.Compare(oldBlob, newBlob, indentHeuristicOption);
Assert.Equal(changes0.Patch, changes1.Patch);
}
}
/// <summary>
/// Handle the specified e if it is a SuccessfulLoginEvent
/// </summary>
/// <param name='e'>
/// The event.
/// </param>
/// <returns>
/// true if handled.
/// </returns>
public override bool Handle(ISyncEvent e)
{
if (e is SuccessfulLoginEvent)
{
var successfulLoginEvent = e as SuccessfulLoginEvent;
var session = successfulLoginEvent.Session;
var remoteRoot = successfulLoginEvent.Session.GetObjectByPath(this.repoInfo.RemotePath) as IFolder;
// Remove former added instances from event Queue.EventManager
if (this.ccaccumulator != null)
{
this.Queue.EventManager.RemoveEventHandler(this.ccaccumulator);
}
if (this.contentChanges != null)
{
this.Queue.EventManager.RemoveEventHandler(this.contentChanges);
}
if (this.alreadyHandledFilter != null)
{
this.Queue.EventManager.RemoveEventHandler(this.alreadyHandledFilter);
}
if (this.selectiveIgnoreFilter != null)
{
this.Queue.EventManager.RemoveEventHandler(this.selectiveIgnoreFilter);
}
if (this.transformer != null)
{
this.Queue.EventManager.RemoveEventHandler(this.transformer);
}
if (this.ignoreChangeDetector != null)
{
this.Queue.EventManager.RemoveEventHandler(this.ignoreChangeDetector);
}
if (session.AreChangeEventsSupported() &&
(this.repoInfo.SupportedFeatures == null || this.repoInfo.SupportedFeatures.GetContentChangesSupport != false))
{
Logger.Info("Session supports content changes");
// Add Accumulator
this.ccaccumulator = new ContentChangeEventAccumulator(session, this.Queue);
this.Queue.EventManager.AddEventHandler(this.ccaccumulator);
// Add Content Change sync algorithm
this.contentChanges = new ContentChanges(session, this.storage, this.Queue);
this.Queue.EventManager.AddEventHandler(this.contentChanges);
// Add Filter of already handled change events
this.alreadyHandledFilter = new IgnoreAlreadyHandledContentChangeEventsFilter(this.storage, session);
this.Queue.EventManager.AddEventHandler(this.alreadyHandledFilter);
}
if (session.SupportsSelectiveIgnore())
{
// Transforms events of ignored folders
this.transformer = new SelectiveIgnoreEventTransformer(this.ignoredStorage, this.Queue);
this.Queue.EventManager.AddEventHandler(this.transformer);
// Filters events of ignored folders
this.selectiveIgnoreFilter = new SelectiveIgnoreFilter(this.ignoredStorage);
this.Queue.EventManager.AddEventHandler(this.selectiveIgnoreFilter);
// Detection if any ignored object has changed its state
this.ignoreChangeDetector = new IgnoreFlagChangeDetection(this.ignoredStorage, new PathMatcher.PathMatcher(this.repoInfo.LocalPath, this.repoInfo.RemotePath), this.Queue);
this.Queue.EventManager.AddEventHandler(this.ignoreChangeDetector);
}
// Add remote object fetcher
if (this.remoteFetcher != null)
{
this.Queue.EventManager.RemoveEventHandler(this.remoteFetcher);
}
this.remoteFetcher = new RemoteObjectFetcher(session, this.storage);
this.Queue.EventManager.AddEventHandler(this.remoteFetcher);
// Add crawler
if (this.crawler != null)
{
this.Queue.EventManager.RemoveEventHandler(this.crawler);
}
this.crawler = new DescendantsCrawler(this.Queue, remoteRoot, this.fileSystemFactory.CreateDirectoryInfo(this.repoInfo.LocalPath), this.storage, this.filter, this.activityListener, this.ignoredStorage);
this.Queue.EventManager.AddEventHandler(this.crawler);
// Add remote object moved accumulator
if (this.romaccumulator != null)
{
this.Queue.EventManager.RemoveEventHandler(this.romaccumulator);
}
this.romaccumulator = new RemoteObjectMovedOrRenamedAccumulator(this.Queue, this.storage, this.fileSystemFactory);
this.Queue.EventManager.AddEventHandler(this.romaccumulator);
// Add sync mechanism
if (this.mechanism != null)
{
this.Queue.EventManager.RemoveEventHandler(this.mechanism);
}
var localDetection = new LocalSituationDetection();
var remoteDetection = new RemoteSituationDetection();
this.mechanism = new SyncMechanism(localDetection, remoteDetection, this.Queue, session, this.storage, this.fileTransmissionStorage, this.activityListener, this.filter);
this.Queue.EventManager.AddEventHandler(this.mechanism);
var localRootFolder = this.fileSystemFactory.CreateDirectoryInfo(this.repoInfo.LocalPath);
Guid rootFolderGuid;
if (!Guid.TryParse(localRootFolder.GetExtendedAttribute(MappedObject.ExtendedAttributeKey), out rootFolderGuid))
{
try {
rootFolderGuid = Guid.NewGuid();
localRootFolder.SetExtendedAttribute(MappedObject.ExtendedAttributeKey, rootFolderGuid.ToString(), false);
} catch (ExtendedAttributeException ex) {
Logger.Warn("Problem on setting Guid of the root path", ex);
rootFolderGuid = Guid.Empty;
}
}
var rootFolder = new MappedObject("/", remoteRoot.Id, MappedObjectType.Folder, null, remoteRoot.ChangeToken)
{
LastRemoteWriteTimeUtc = remoteRoot.LastModificationDate,
Guid = rootFolderGuid
};
Logger.Debug("Saving Root Folder to DataBase");
this.storage.SaveMappedObject(rootFolder);
// Sync up everything that changed
// since we've been offline
// start full crawl sync on beginning
this.Queue.AddEvent(new StartNextSyncEvent(true));
return(true);
}
return(false);
}
public ModifiedInfo(ContentChanges changes)
{
Patch = changes.Patch;
Binary = changes.IsBinaryComparison;
Hunks = Diff.ParseChanges(Patch);
}
static string CanonicalChangedLines(ContentChanges changes)
{
// Create an ordered representation of lines that have been added or removed
return(string.Join("\n", changes.Patch.Split('\n').Where(l => l.StartsWith("+") || l.StartsWith("-")).OrderBy(l => l)));
}
private SingleStepEventQueue CreateQueue(Mock <ISession> session, IMetaDataStorage storage, ObservableHandler observer, IFileSystemInfoFactory fsFactory = null)
{
var manager = new SyncEventManager();
SingleStepEventQueue queue = new SingleStepEventQueue(manager);
manager.AddEventHandler(observer);
var connectionScheduler = new ConnectionScheduler(new RepoInfo(), queue, Mock.Of <ISessionFactory>(), Mock.Of <IAuthenticationProvider>());
manager.AddEventHandler(connectionScheduler);
var changes = new ContentChanges(session.Object, storage, queue, this.maxNumberOfContentChanges, this.isPropertyChangesSupported);
manager.AddEventHandler(changes);
var transformer = new ContentChangeEventTransformer(queue, storage, fsFactory);
manager.AddEventHandler(transformer);
var ccaccumulator = new ContentChangeEventAccumulator(session.Object, queue);
manager.AddEventHandler(ccaccumulator);
var remoteFetcher = new RemoteObjectFetcher(session.Object, storage);
manager.AddEventHandler(remoteFetcher);
var localFetcher = new LocalObjectFetcher(storage.Matcher, fsFactory);
manager.AddEventHandler(localFetcher);
var watcher = new Strategy.WatcherConsumer(queue);
manager.AddEventHandler(watcher);
var localDetection = new LocalSituationDetection();
var remoteDetection = new RemoteSituationDetection();
var transmissionManager = new ActiveActivitiesManager();
var activityAggregator = new ActivityListenerAggregator(Mock.Of <IActivityListener>(), transmissionManager);
var ignoreFolderFilter = new IgnoredFoldersFilter();
var ignoreFolderNameFilter = new IgnoredFolderNameFilter();
var ignoreFileNamesFilter = new IgnoredFileNamesFilter();
var invalidFolderNameFilter = new InvalidFolderNameFilter();
var filterAggregator = new FilterAggregator(ignoreFileNamesFilter, ignoreFolderNameFilter, invalidFolderNameFilter, ignoreFolderFilter);
var syncMechanism = new SyncMechanism(localDetection, remoteDetection, queue, session.Object, storage, activityAggregator, filterAggregator, isServerAbleToUpdateModificationDate: true);
manager.AddEventHandler(syncMechanism);
var remoteFolder = MockSessionUtil.CreateCmisFolder();
var localFolder = new Mock <IDirectoryInfo>();
var generator = new CrawlEventGenerator(storage, fsFactory);
var treeBuilder = new DescendantsTreeBuilder(storage, remoteFolder.Object, localFolder.Object, filterAggregator);
var notifier = new CrawlEventNotifier(queue);
var crawler = new DescendantsCrawler(queue, treeBuilder, generator, notifier, Mock.Of <IActivityListener>());
manager.AddEventHandler(crawler);
var permissionDenied = new GenericHandleDublicatedEventsFilter <PermissionDeniedEvent, ConfigChangedEvent>();
manager.AddEventHandler(permissionDenied);
var alreadyAddedFilter = new IgnoreAlreadyHandledFsEventsFilter(storage, fsFactory);
manager.AddEventHandler(alreadyAddedFilter);
var ignoreContentChangesFilter = new IgnoreAlreadyHandledContentChangeEventsFilter(storage, session.Object);
manager.AddEventHandler(ignoreContentChangesFilter);
var delayRetryAndNextSyncEventHandler = new DelayRetryAndNextSyncEventHandler(queue);
manager.AddEventHandler(delayRetryAndNextSyncEventHandler);
/* This is not implemented yet
* var failedOperationsFilder = new FailedOperationsFilter(queue);
* manager.AddEventHandler(failedOperationsFilder);
*/
var reportingFilter = new ReportingFilter(queue, ignoreFolderFilter, ignoreFileNamesFilter, ignoreFolderNameFilter, invalidFolderNameFilter);
manager.AddEventHandler(reportingFilter);
var debugHandler = new DebugLoggingHandler();
manager.AddEventHandler(debugHandler);
var movedOrRenamed = new RemoteObjectMovedOrRenamedAccumulator(queue, storage, fsFactory);
manager.AddEventHandler(movedOrRenamed);
return(queue);
}
