public void ConstructorThrowsExceptionIfFiltersAreNull()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            Assert.Throws <ArgumentNullException>(() => new RemoteObjectDeleted(session.Object, Mock.Of <IMetaDataStorage>(), null));
        }
Beispiel #2
0
        public void ConstructorThrowsExceptionIfSolverIsNull()
        {
            Mock <ISession> session = new Mock <ISession>();

            session.SetupTypeSystem();
            Assert.Throws <ArgumentNullException>(() => new LocalObjectChangedRemoteObjectRenamed(session.Object, Mock.Of <IMetaDataStorage>(), null));
        }
Beispiel #3
0
        public void ConstructorThrowsExceptionIfTransmissionManagerIsNull()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            Assert.Throws <ArgumentNullException>(() => new LocalObjectChanged(session.Object, Mock.Of <IMetaDataStorage>(), null, null));
        }
        public void DefaultConstructorTest()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            new RemoteObjectRenamed(session.Object, Mock.Of <IMetaDataStorage>());
        }
Beispiel #5
0
        public void RunFSEventFileDeleted()
        {
            var storage = this.GetInitializedStorage();
            var path    = new Mock <IFileInfo>();
            var name    = "a";

            path.Setup(p => p.FullName).Returns(Path.Combine(this.localRoot, name));
            string id = "id";

            var mappedObject = new MappedObject(name, id, MappedObjectType.File, null, "changeToken");

            storage.SaveMappedObject(mappedObject);

            var session = new Mock <ISession>();

            session.SetupSessionDefaultValues();
            session.SetupChangeLogToken("default");
            session.SetupTypeSystem();
            IDocument remote = MockOfIDocumentUtil.CreateRemoteDocumentMock(null, id, name, (string)null, changeToken: "changeToken").Object;

            session.Setup(s => s.GetObject(id, It.IsAny <IOperationContext>())).Returns(remote);
            var myEvent = new FSEvent(WatcherChangeTypes.Deleted, path.Object.FullName, false);
            var queue   = this.CreateQueue(session, storage);

            queue.AddEvent(myEvent);
            queue.Run();

            session.Verify(f => f.Delete(It.Is <IObjectId>(i => i.Id == id), true), Times.Once());
            Assert.That(storage.GetObjectByRemoteId(id), Is.Null);
        }
Beispiel #6
0
        public void ContentChangeIndicatesFolderDeletionOfExistingFolder()
        {
            var    storage = this.GetInitializedStorage();
            var    name    = "a";
            string path    = Path.Combine(this.localRoot, name);
            string id      = "1";
            Mock <IFileSystemInfoFactory> fsFactory = new Mock <IFileSystemInfoFactory>();
            var dirInfo = new Mock <IDirectoryInfo>();

            dirInfo.Setup(d => d.Exists).Returns(true);
            dirInfo.Setup(d => d.FullName).Returns(path);
            fsFactory.AddIDirectoryInfo(dirInfo.Object);
            var mappedObject = new MappedObject(name, id, MappedObjectType.Folder, null, null);

            storage.SaveMappedObject(mappedObject);
            storage.ChangeLogToken = "oldtoken";

            Mock <ISession> session = MockSessionUtil.GetSessionMockReturningFolderChange(DotCMIS.Enums.ChangeType.Deleted, id);

            session.SetupTypeSystem();
            var queue = this.CreateQueue(session, storage, fsFactory.Object);

            queue.RunStartSyncEvent();
            dirInfo.Verify(d => d.Delete(false), Times.Once());
            Assert.That(storage.GetObjectByRemoteId(id), Is.Null);
        }
Beispiel #7
0
        public void ConstructorTakesSessionAndStorageAndDateSyncDisabled()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            new LocalObjectChangedRemoteObjectChanged(session.Object, Mock.Of <IMetaDataStorage>(), null, new TransmissionManager());
        }
Beispiel #8
0
        public void RunFSEventFolderDeleted()
        {
            var storage = this.GetInitializedStorage();
            var path    = new Mock <IFileInfo>();
            var name    = "a";

            path.Setup(p => p.FullName).Returns(Path.Combine(this.localRoot, name));
            string id = "id";

            var mappedObject = new MappedObject(name, id, MappedObjectType.Folder, null, null);

            storage.SaveMappedObject(mappedObject);

            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            session.SetupSessionDefaultValues();
            session.SetupChangeLogToken("default");
            IFolder remote = MockOfIFolderUtil.CreateRemoteFolderMock(id, name, (string)null).Object;

            session.Setup(s => s.GetObject(id, It.IsAny <IOperationContext>())).Returns(remote);
            var myEvent = new FSEvent(WatcherChangeTypes.Deleted, path.Object.FullName, true);
            var queue   = this.CreateQueue(session, storage);

            queue.AddEvent(myEvent);
            queue.Run();

            Mock.Get(remote).Verify(d => d.DeleteTree(false, UnfileObject.DeleteSinglefiled, true), Times.Once());
            Assert.That(storage.GetObjectByRemoteId(id), Is.Null);
        }
        public void DefaultConstructorTest()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            new RemoteObjectDeleted(session.Object, Mock.Of <IMetaDataStorage>(), Mock.Of <IFilterAggregator>());
        }
Beispiel #10
0
        public void DefaultConstructorTest()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            new LocalObjectChanged(session.Object, Mock.Of <IMetaDataStorage>(), new ActiveActivitiesManager());
        }
        public void ConstructorSetsServerPropertyCorrectly([Values(true, false)]bool serverCanModifyLastModificationDate) {
            var session = new Mock<ISession>();
            session.SetupTypeSystem(serverCanModifyLastModificationDate);
            var underTest = new SolverClass(session.Object, Mock.Of<IMetaDataStorage>());

            Assert.That(underTest.GetModification(), Is.EqualTo(serverCanModifyLastModificationDate));
        }
Beispiel #12
0
        public void DefaultConstructorTest()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            new LocalObjectChanged(session.Object, Mock.Of <IMetaDataStorage>(), null, Mock.Of <ITransmissionManager>());
        }
        public void ConstructorSetsModificationPossibilityToFalse()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem(false);
            var underTest = new SolverClass(session.Object, Mock.Of <IMetaDataStorage>());

            Assert.That(underTest.GetModification(), Is.False);
        }
        public void ConstructorSetsServerPropertyCorrectly([Values(true, false)] bool serverCanModifyLastModificationDate)
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem(serverCanModifyLastModificationDate);
            var underTest = new SolverClass(session.Object, Mock.Of <IMetaDataStorage>());

            Assert.That(underTest.GetModification(), Is.EqualTo(serverCanModifyLastModificationDate));
        }
        public void EnsureLegalCharactersThrowsExceptionIfFilenameContainsUtf8Character() {
            var session = new Mock<ISession>();
            session.SetupTypeSystem();
            var underTest = new SolverClass(session.Object, Mock.Of<IMetaDataStorage>());
            var exception = new CmisConstraintException();
            var fileInfo = Mock.Of<IFileSystemInfo>(f => f.Name == @"ä" && f.FullName == @"ä");

            Assert.Throws<InteractionNeededException>(() => underTest.CallEnsureThatLocalFileNameContainsLegalCharacters(fileInfo, exception));
        }
        public void ConstructorSetsServerPropertyCorrectly()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem(true);

            var underTest = new SolverClass(session.Object, Mock.Of <IMetaDataStorage>());

            Assert.That(underTest.GetModification(), Is.True);
        }
        public void UploadFileClosesTransmissionOnIOException()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();

            var underTest = new SolverClass(session.Object, Mock.Of <IMetaDataStorage>());

            underTest.Upload(null, null, null);
            Assert.Fail("TODO");
        }
        public void ConstructorSetsPropertiesCorrectly([Values(true, false)]bool withGivenTransmissionStorage) {
            var session = new Mock<ISession>();
            session.SetupTypeSystem();
            var storage = Mock.Of<IMetaDataStorage>();
            var transmissionStorage = withGivenTransmissionStorage ? Mock.Of<IFileTransmissionStorage>() : null;
            var underTest = new SolverClass(session.Object, storage, transmissionStorage);

            Assert.That(underTest.GetSession(), Is.EqualTo(session.Object));
            Assert.That(underTest.GetStorage(), Is.EqualTo(storage));
            Assert.That(underTest.GetTransmissionStorage(), Is.EqualTo(transmissionStorage));
        }
        public void EnsureLegalCharactersIfFilenameIsValid()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            var underTest = new SolverClass(session.Object, Mock.Of <IMetaDataStorage>());
            var exception = new CmisConstraintException();
            var fileInfo  = Mock.Of <IFileSystemInfo>(f => f.Name == "foo");

            underTest.CallEnsureThatLocalFileNameContainsLegalCharacters(fileInfo, exception);
        }
        public void EnsureLegalCharactersThrowsExceptionIfFilenameContainsUtf8Character()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            var underTest = new SolverClass(session.Object, Mock.Of <IMetaDataStorage>());
            var exception = new CmisConstraintException();
            var fileInfo  = Mock.Of <IFileSystemInfo>(f => f.Name == @"ä" && f.FullName == @"ä");

            Assert.Throws <InteractionNeededException>(() => underTest.CallEnsureThatLocalFileNameContainsLegalCharacters(fileInfo, exception));
        }
Beispiel #21
0
        public void ContentChangeIndicatesFolderRenameOfExistingFolder()
        {
            var    storage         = this.GetInitializedStorage();
            string name            = "a";
            string newName         = "b";
            string parentId        = "parentId";
            string path            = Path.Combine(this.localRoot, name);
            string newPath         = Path.Combine(this.localRoot, newName);
            string id              = "1";
            string lastChangeToken = "changeToken";
            Guid   guid            = Guid.NewGuid();
            Mock <IFileSystemInfoFactory> fsFactory = new Mock <IFileSystemInfoFactory>();
            var dirInfo = new Mock <IDirectoryInfo>();

            dirInfo.Setup(d => d.Exists).Returns(true);
            dirInfo.Setup(d => d.FullName).Returns(path);
            dirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>(r => r.FullName == this.localRoot));
            fsFactory.AddIDirectoryInfo(dirInfo.Object);
            var mappedRootObject = new MappedObject("/", parentId, MappedObjectType.Folder, null, storage.ChangeLogToken);

            storage.SaveMappedObject(mappedRootObject);
            var mappedObject = new MappedObject(name, id, MappedObjectType.Folder, parentId, null)
            {
                Guid = guid
            };

            storage.SaveMappedObject(mappedObject);
            storage.ChangeLogToken = "oldChangeToken";
            Console.WriteLine(storage.ToFindString());

            Mock <ISession> session = MockSessionUtil.GetSessionMockReturningFolderChange(DotCMIS.Enums.ChangeType.Updated, id, newName, this.remoteRoot + "/" + newName, parentId, lastChangeToken);

            session.SetupTypeSystem();

            var queue = this.CreateQueue(session, storage, fsFactory.Object);

            dirInfo.Setup(d => d.MoveTo(It.IsAny <string>()))
            .Callback(() => {
                queue.AddEvent(Mock.Of <IFSMovedEvent>(fs => fs.IsDirectory == true && fs.OldPath == path && fs.LocalPath == newPath && fs.Type == WatcherChangeTypes.Renamed));
                var newDirInfo = new Mock <IDirectoryInfo>();
                newDirInfo.Setup(d => d.Exists).Returns(true);
                newDirInfo.Setup(d => d.FullName).Returns(newPath);
                newDirInfo.Setup(d => d.Uuid).Returns(guid);
                newDirInfo.Setup(d => d.Parent).Returns(Mock.Of <IDirectoryInfo>(r => r.FullName == this.localRoot));
                fsFactory.AddIDirectoryInfo(newDirInfo.Object);
            });

            queue.RunStartSyncEvent();
            dirInfo.Verify(d => d.MoveTo(It.Is <string>(p => p.Equals(newPath))), Times.Once());
            Assert.That(storage.GetObjectByRemoteId(id), Is.Not.Null);
            Assert.That(storage.GetObjectByRemoteId(id).Name, Is.EqualTo(newName));
            Assert.That(storage.GetObjectByLocalPath(Mock.Of <IDirectoryInfo>(d => d.FullName == path)), Is.Null);
            Assert.That(storage.GetObjectByLocalPath(Mock.Of <IDirectoryInfo>(d => d.FullName == newPath)), Is.Not.Null);
        }
        public void ConstructorSetsPropertiesCorrectly()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            var storage = Mock.Of <IMetaDataStorage>();

            var underTest = new SolverClass(session.Object, storage);

            Assert.That(underTest.GetSession(), Is.EqualTo(session.Object));
            Assert.That(underTest.GetStorage(), Is.EqualTo(storage));
        }
        public void ConstructorSetsPropertiesCorrectly([Values(true, false)] bool withGivenTransmissionStorage)
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            var storage             = Mock.Of <IMetaDataStorage>();
            var transmissionStorage = withGivenTransmissionStorage ? Mock.Of <IFileTransmissionStorage>() : null;
            var underTest           = new SolverClass(session.Object, storage, transmissionStorage);

            Assert.That(underTest.GetSession(), Is.EqualTo(session.Object));
            Assert.That(underTest.GetStorage(), Is.EqualTo(storage));
            Assert.That(underTest.GetTransmissionStorage(), Is.EqualTo(transmissionStorage));
        }
Beispiel #24
0
        public void RunFakeEvent()
        {
            var session = new Mock <ISession>();

            session.SetupTypeSystem();
            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));
        }
        private static SuccessfulLoginEvent CreateNewSessionEvent(bool changeEventSupported, string id = "i", string token = "t")
        {
            var session      = new Mock <ISession>();
            var remoteObject = new Mock <IFolder>();

            remoteObject.Setup(r => r.Id).Returns(id);
            remoteObject.Setup(r => r.ChangeToken).Returns(token);
            session.SetupTypeSystem();
            session.Setup(s => s.GetObjectByPath(It.IsAny <string>())).Returns(remoteObject.Object);
            if (changeEventSupported)
            {
                session.Setup(s => s.RepositoryInfo.Capabilities.ChangesCapability).Returns(CapabilityChanges.All);
            }

            return(new SuccessfulLoginEvent(new Uri("http://example.com"), session.Object));
        }
Beispiel #26
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 #27
0
        public void ContentChangeIndicatesFolderCreation()
        {
            string rootFolderName  = "/";
            string rootFolderId    = "root";
            string folderName      = "folder";
            string parentId        = "root";
            string lastChangeToken = "changeToken";
            Mock <IFileSystemInfoFactory> fsFactory = new Mock <IFileSystemInfoFactory>();
            var dirInfo = fsFactory.AddDirectory(Path.Combine(this.localRoot, folderName));

            string          id      = "1";
            Mock <ISession> session = MockSessionUtil.GetSessionMockReturningFolderChange(DotCMIS.Enums.ChangeType.Created, id, folderName, this.remoteRoot + "/" + folderName, parentId, lastChangeToken);

            session.SetupTypeSystem();
            var storage = this.GetInitializedStorage();

            storage.ChangeLogToken = "oldtoken";
            storage.SaveMappedObject(new MappedObject(rootFolderName, rootFolderId, MappedObjectType.Folder, null, "oldtoken"));
            var queue = this.CreateQueue(session, storage, fsFactory.Object);
            var fsFolderCreatedEvent = new Mock <IFSEvent>();

            fsFolderCreatedEvent.Setup(f => f.IsDirectory).Returns(true);
            fsFolderCreatedEvent.Setup(f => f.LocalPath).Returns(Path.Combine(this.localRoot, folderName));
            fsFolderCreatedEvent.Setup(f => f.Type).Returns(WatcherChangeTypes.Created);
            dirInfo.Setup(d => d.Create()).Callback(delegate { queue.AddEvent(fsFolderCreatedEvent.Object); });

            queue.RunStartSyncEvent();

            dirInfo.Verify(d => d.Create(), Times.Once());
            var mappedObject = storage.GetObjectByRemoteId(id);

            Assert.That(mappedObject, Is.Not.Null);
            Assert.That(mappedObject.RemoteObjectId, Is.EqualTo(id), "RemoteObjectId incorrect");
            Assert.That(mappedObject.Name, Is.EqualTo(folderName), "Name incorrect");
            Assert.That(mappedObject.ParentId, Is.EqualTo(parentId), "ParentId incorrect");
            Assert.That(mappedObject.LastChangeToken, Is.EqualTo(lastChangeToken), "LastChangeToken incorrect");
            Assert.That(mappedObject.Type, Is.EqualTo(MappedObjectType.Folder), "Type incorrect");
        }
Beispiel #28
0
        public void ContentChangeIndicatesFolderMove()
        {
            // Moves /a/b to /b
            string rootFolderId = "rootId";
            string folderAName  = "a";
            string folderAId    = "aid";
            string folderBName  = "b";
            string folderBId    = "bid";

            string lastChangeToken = "changeToken";

            Mock <IFileSystemInfoFactory> fsFactory = new Mock <IFileSystemInfoFactory>();
            var folderBInfo = fsFactory.AddDirectory(Path.Combine(this.localRoot, folderAName, folderBName));

            Mock <ISession> session = MockSessionUtil.GetSessionMockReturningFolderChange(DotCMIS.Enums.ChangeType.Updated, folderBId, folderBName, this.remoteRoot + "/" + folderBName, rootFolderId, lastChangeToken);

            session.SetupTypeSystem();

            var storage = this.GetInitializedStorage();

            storage.ChangeLogToken = "oldtoken";
            var mappedRootObject = new MappedObject("/", rootFolderId, MappedObjectType.Folder, null, storage.ChangeLogToken);

            storage.SaveMappedObject(mappedRootObject);
            var mappedAObject = new MappedObject(folderAName, folderAId, MappedObjectType.Folder, rootFolderId, storage.ChangeLogToken);

            storage.SaveMappedObject(mappedAObject);
            var mappedBObject = new MappedObject(folderBName, folderBId, MappedObjectType.Folder, folderAId, storage.ChangeLogToken);

            storage.SaveMappedObject(mappedBObject);

            var queue = this.CreateQueue(session, storage, fsFactory.Object);

            queue.RunStartSyncEvent();

            folderBInfo.Verify(d => d.MoveTo(Path.Combine(this.localRoot, folderBName)), Times.Once());
        }
        public void EnsureLegalCharactersIfFilenameIsValid() {
            var session = new Mock<ISession>();
            session.SetupTypeSystem();
            var underTest = new SolverClass(session.Object, Mock.Of<IMetaDataStorage>());
            var exception = new CmisConstraintException();
            var fileInfo = Mock.Of<IFileSystemInfo>(f => f.Name == "foo");

            underTest.CallEnsureThatLocalFileNameContainsLegalCharacters(fileInfo, exception);
        }
        public void UploadFileClosesTransmissionOnIOException() {
            var session = new Mock<ISession>();
            session.SetupTypeSystem();

            var underTest = new SolverClass(session.Object, Mock.Of<IMetaDataStorage>());

            underTest.Upload(null, null, null);
            Assert.Fail("TODO");
        }
 public void DefaultConstructorTest() {
     var session = new Mock<ISession>();
     session.SetupTypeSystem();
     new RemoteObjectRenamed(session.Object, Mock.Of<IMetaDataStorage>());
 }
 public void ConstructorTakesSessionAndStorageAndDateSyncDisabled() {
     var session = new Mock<ISession>();
     session.SetupTypeSystem();
     new LocalObjectChangedRemoteObjectChanged(session.Object, Mock.Of<IMetaDataStorage>(), null, new TransmissionManager());
 }
Beispiel #33
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.SetupSessionDefaultValues();
     session.SetupChangeLogToken("default");
     session.SetupTypeSystem();
     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)));
 }
        private static SuccessfulLoginEvent CreateNewSessionEvent(bool changeEventSupported, bool supportsSelectiveIgnore = true, string id = "i", string token = "t") {
            var session = new Mock<ISession>();
            var remoteObject = new Mock<IFolder>();
            remoteObject.Setup(r => r.Id).Returns(id);
            remoteObject.Setup(r => r.ChangeToken).Returns(token);
            remoteObject.Setup(r => r.Path).Returns("path");
            session.SetupTypeSystem(true, supportsSelectiveIgnore);
            session.Setup(s => s.GetObjectByPath(It.IsAny<string>())).Returns(remoteObject.Object);
            if (changeEventSupported) {
                session.Setup(s => s.RepositoryInfo.Capabilities.ChangesCapability).Returns(CapabilityChanges.All);
            }

            return new SuccessfulLoginEvent(new Uri("http://example.com"), session.Object);
        }
Beispiel #35
0
        public void RunFSEventFolderDeleted() {
            var storage = this.GetInitializedStorage();
            var path = new Mock<IFileInfo>();
            var name = "a";
            path.Setup(p => p.FullName).Returns(Path.Combine(this.localRoot, name));
            string id = "id";

            var mappedObject = new MappedObject(name, id, MappedObjectType.Folder, null, "changeToken");
            storage.SaveMappedObject(mappedObject);

            var session = new Mock<ISession>();
            session.SetupSessionDefaultValues();
            session.SetupChangeLogToken("default");
            session.SetupTypeSystem();
            IFolder remote = MockOfIFolderUtil.CreateRemoteFolderMock(id, name, (string)null, changetoken: "changeToken").Object;
            session.Setup(s => s.GetObject(id, It.IsAny<IOperationContext>())).Returns(remote);
            var myEvent = new FSEvent(WatcherChangeTypes.Deleted, path.Object.FullName, true);
            var queue = this.CreateQueue(session, storage);
            queue.AddEvent(myEvent);
            queue.Run();

            Mock.Get(remote).Verify(d => d.DeleteTree(false, UnfileObject.DeleteSinglefiled, true), Times.Once());
            Assert.That(storage.GetObjectByRemoteId(id), Is.Null);
        }
Beispiel #36
0
 public void RunFakeEvent() {
     var session = new Mock<ISession>();
     session.SetupTypeSystem();
     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));
 }
 public void DefaultConstructorTest() {
     var session = new Mock<ISession>();
     session.SetupTypeSystem();
     new RemoteObjectDeleted(session.Object, Mock.Of<IMetaDataStorage>(), Mock.Of<IFilterAggregator>());
 }
 public void ConstructorThrowsExceptionIfFiltersAreNull() {
     var session = new Mock<ISession>();
     session.SetupTypeSystem();
     Assert.Throws<ArgumentNullException>(() => new RemoteObjectDeleted(session.Object, Mock.Of<IMetaDataStorage>(), null));
 }
 public void ConstructorThrowsExceptionIfTransmissionManagerIsNull() {
     var session = new Mock<ISession>();
     session.SetupTypeSystem();
     Assert.Throws<ArgumentNullException>(() => new LocalObjectChanged(session.Object, Mock.Of<IMetaDataStorage>(), null, null));
 }
 public void ConstructorThrowsExceptionIfSolverIsNull() {
     Mock<ISession> session = new Mock<ISession>();
     session.SetupTypeSystem();
     Assert.Throws<ArgumentNullException>(() => new LocalObjectRenamedRemoteObjectChanged(session.Object, Mock.Of<IMetaDataStorage>(), null));
 }
 public void DefaultConstructorTest() {
     var session = new Mock<ISession>();
     session.SetupTypeSystem();
     new LocalObjectChanged(session.Object, Mock.Of<IMetaDataStorage>(), null, Mock.Of<ITransmissionManager>());
 }