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 void RemoteFolderDeletionWithoutLocalFolder()
        {
            Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();

            Mock <ISession>   session  = MockSessionUtil.GetSessionMockReturningFolderChange(DotCMIS.Enums.ChangeType.Deleted);
            ObservableHandler observer = this.RunQueue(session, storage);

            Assert.That(observer.List.Count, Is.EqualTo(0));
        }
        public void RemoteFolderCreation()
        {
            Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();

            Mock <ISession>   session  = MockSessionUtil.GetSessionMockReturningFolderChange(DotCMIS.Enums.ChangeType.Created);
            ObservableHandler observer = this.RunQueue(session, storage);

            observer.AssertGotSingleFolderEvent(MetaDataChangeType.CREATED);
        }
        public void LocallyNotExistingRemoteDocumentUpdated()
        {
            Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();

            Mock <ISession> session = MockSessionUtil.GetSessionMockReturningDocumentChange(DotCMIS.Enums.ChangeType.Updated, DefaultId, null);

            ObservableHandler observer = this.RunQueue(session, storage);

            observer.AssertGotSingleFileEvent(MetaDataChangeType.CREATED, ContentChangeType.CREATED);
        }
        public void RemoteDocumentCreationWithContent()
        {
            Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();

            Mock <ISession> session = MockSessionUtil.GetSessionMockReturningDocumentChange(DotCMIS.Enums.ChangeType.Created, DefaultId, "someStreamId");

            ObservableHandler observer = this.RunQueue(session, storage);

            observer.AssertGotSingleFileEvent(MetaDataChangeType.CREATED, ContentChangeType.CREATED);
        }
        public MainWindow()
        {
            InitializeComponent();
              DataContext = this;
              var bindings = new Bindings();
              LoadKernel( bindings );
              _session = new Session.Session();
              _sessionLogic = new SessionLogic( _dbConn );

              flagHandler = new ObservableHandler<IDbConn>( _dbConn );
              flagHandler.Add( "HasDummyRan", OnDbConnHasDummyRanChanged );
        }
        public void RemoteDeletionChangeTest()
        {
            Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();
            var file = Mock.Of <IFileInfo>(f => f.FullName == "path");

            storage.AddLocalFile(file, DefaultId);

            Mock <ISession>   session  = MockSessionUtil.GetSessionMockReturningDocumentChange(DotCMIS.Enums.ChangeType.Deleted, DefaultId, null);
            ObservableHandler observer = this.RunQueue(session, storage);

            observer.AssertGotSingleFileEvent(MetaDataChangeType.DELETED, ContentChangeType.NONE);
        }
Beispiel #8
0
        public void RunFakeEvent()
        {
            var session  = new Mock <ISession>();
            var observer = new ObservableHandler();
            var storage  = this.GetInitializedStorage();
            var queue    = this.CreateQueue(session, storage, observer);
            var myEvent  = new Mock <ISyncEvent>();

            queue.AddEvent(myEvent.Object);
            queue.Run();
            Assert.That(observer.List.Count, Is.EqualTo(1));
        }
Beispiel #9
0
        public MainWindow()
        {
            InitializeComponent();
            DataContext = this;
            var bindings = new Bindings();

            LoadKernel(bindings);
            _session      = new Session.Session();
            _sessionLogic = new SessionLogic(_dbConn);

            flagHandler = new ObservableHandler <IDbConn>(_dbConn);
            flagHandler.Add("HasDummyRan", OnDbConnHasDummyRanChanged);
        }
        public void RemoteSecurityChangeOfExistingFile()
        {
            Mock <IMetaDataStorage> storage = MockMetaDataStorageUtil.GetMetaStorageMockWithToken();
            var path = Mock.Of <IFileInfo>(f => f.FullName == "path");

            storage.AddLocalFile(path, DefaultId);

            Mock <ISession>   session  = MockSessionUtil.GetSessionMockReturningDocumentChange(DotCMIS.Enums.ChangeType.Security, DefaultId);
            ObservableHandler observer = this.RunQueue(session, storage);

            storage.Verify(s => s.GetObjectByRemoteId(DefaultId), Times.Once());

            observer.AssertGotSingleFileEvent(MetaDataChangeType.CHANGED, ContentChangeType.NONE);
        }
Beispiel #11
0
        public void RunStartNewSyncEvent()
        {
            string rootFolderName = "/";
            string rootFolderId   = "root";
            var    storage        = this.GetInitializedStorage();

            storage.SaveMappedObject(new MappedObject(rootFolderName, rootFolderId, MappedObjectType.Folder, null, "oldtoken"));
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            session.SetupSessionDefaultValues();
            session.SetupChangeLogToken("default");
            var observer = new ObservableHandler();
            var queue    = this.CreateQueue(session, storage, observer);

            queue.RunStartSyncEvent();
            Assert.That(observer.List.Count, Is.EqualTo(1));
            Assert.That(observer.List[0], Is.TypeOf(typeof(FullSyncCompletedEvent)));
        }
Beispiel #12
0
        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);
        }