public void OnDatasetCreated() { var context = new Mock<IContextAware>(); { context.Setup(c => c.IsSynchronized) .Returns(true); } var project = new Mock<IProject>(); var facade = new ProjectFacade(project.Object); var model = new ProjectDescriptionModel(context.Object, facade); var propertyChangedWasRaised = 0; var properties = new List<string>(); model.PropertyChanged += (s, e) => { propertyChangedWasRaised++; properties.Add(e.PropertyName); }; project.Raise(p => p.OnDatasetCreated += null, EventArgs.Empty); Assert.AreEqual(1, propertyChangedWasRaised); Assert.That( properties, Is.EquivalentTo( new List<string> { "NumberOfDatasets", })); }
public void CanUndoWithHistoryWithoutRollBack() { var history = new Mock<ITimeline>(); { history.Setup(h => h.CanRollBack) .Returns(false); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } Func<string, IDisposable> timerFunc = s => new MockDisposable(); var command = new UndoCommand(projectLink.Object, timerFunc); Assert.IsFalse(command.CanExecute(null)); }
public void Initialize() { var context = new Mock<IContextAware>(); var view = new Mock<IProjectDescriptionView>(); { view.SetupSet(v => v.Model = It.IsAny<ProjectDescriptionModel>()) .Verifiable(); } var parameter = new ProjectDescriptionParameter(context.Object); var project = new Mock<IProject>(); var facade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(facade); } var container = new Mock<IDependencyInjectionProxy>(); { container.Setup(c => c.Resolve<IContextAware>()) .Returns(context.Object); container.Setup(c => c.Resolve<ILinkToProjects>()) .Returns(projectLink.Object); } var presenter = new ProjectDescriptionPresenter(container.Object); ((IPresenter)presenter).Initialize(view.Object, parameter); Assert.AreSame(view.Object, presenter.View); Assert.AreSame(parameter, presenter.Parameter); view.VerifySet(v => v.Model = It.IsAny<ProjectDescriptionModel>(), Times.Once()); }
public void ActivateDataset() { var history = new Mock<ITimeline>(); { history.Setup(h => h.Mark()) .Verifiable(); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } var proxy = new Mock<IProxyDataset>(); { proxy.Setup(p => p.IsActivated) .Returns(false); proxy.Setup(p => p.CanActivate) .Returns(true); proxy.Setup( p => p.Activate( It.IsAny<DistributionLocations>(), It.IsAny<Func<IEnumerable<DistributionSuggestion>, SelectedProposal>>(), It.IsAny<CancellationToken>())) .Returns<DistributionLocations, Func<IEnumerable<DistributionSuggestion>, SelectedProposal>, CancellationToken>( (d, f, c) => Task.Factory.StartNew( () => { }, c, TaskCreationOptions.None, new CurrentThreadTaskScheduler())) .Verifiable(); } var dataset = new DatasetFacade(proxy.Object); Func<IEnumerable<DistributionSuggestion>, SelectedProposal> selectionFunc = suggestions => null; Func<string, IDisposable> timerFunc = s => new MockDisposable(); var command = new ActivateDatasetCommand(projectLink.Object, dataset, selectionFunc, timerFunc); command.Execute(null); proxy.Verify( p => p.Activate( It.IsAny<DistributionLocations>(), It.IsAny<Func<IEnumerable<DistributionSuggestion>, SelectedProposal>>(), It.IsAny<CancellationToken>()), Times.Once()); history.Verify(h => h.Mark(), Times.Once()); }
public void OnDatasetDeleted() { var project = new Mock<IProject>(); var facade = new ProjectFacade(project.Object); bool eventRaised = false; facade.OnDatasetDeleted += (s, e) => { eventRaised = true; }; project.Raise(p => p.OnDatasetDeleted += null, EventArgs.Empty); Assert.IsTrue(eventRaised); }
public void OnNameUpdate() { var project = new Mock<IProject>(); var facade = new ProjectFacade(project.Object); bool eventRaised = false; facade.OnNameChanged += (s, e) => { eventRaised = true; }; project.Raise(p => p.OnNameChanged += null, new ValueChangedEventArgs<string>("newName")); Assert.IsTrue(eventRaised); }
public void Name() { var project = new Mock<IProject>(); { project.SetupProperty(p => p.Name); } var facade = new ProjectFacade(project.Object); var name = "name"; facade.Name = name; Assert.AreEqual(name, facade.Name); }
/// <summary> /// Initializes a new instance of the <see cref="ProjectDescriptionModel"/> class. /// </summary> /// <param name="context">The context that is used to execute actions on the UI thread.</param> /// <param name="facade">The project that holds all the data.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="context"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="facade"/> is <see langword="null" />. /// </exception> public ProjectDescriptionModel(IContextAware context, ProjectFacade facade) : base(context) { { Enforce.Argument(() => facade); } m_Project = facade; m_Project.OnNameChanged += (s, e) => Notify(() => Name); m_Project.OnSummaryChanged += (s, e) => Notify(() => Summary); m_Project.OnDatasetCreated += (s, e) => Notify(() => NumberOfDatasets); m_Project.OnDatasetDeleted += (s, e) => Notify(() => NumberOfDatasets); }
/// <summary> /// Initializes a new instance of the <see cref="ScriptBackEndProjectFacade"/> class. /// </summary> /// <param name="current">The object that describes the current project.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="current"/> is <see langword="null" />. /// </exception> public ScriptBackEndProjectFacade(ProjectFacade current) { { Enforce.Argument(() => current); } m_Current = current; m_Current.OnClosed += (s, e) => RaiseOnProjectClosed(); m_Current.OnDatasetCreated += (s, e) => RaiseOnDatasetCreated(); m_Current.OnDatasetDeleted += (s, e) => RaiseOnDatasetDeleted(); m_Current.OnNameChanged += (s, e) => RaiseOnProjectNameUpdated(); m_Current.OnSummaryChanged += (s, e) => RaiseOnProjectSummaryUpdated(); }
public void Initialize() { var context = new Mock<IContextAware>(); var progress = new Mock<ITrackSteppingProgress>(); var aggregator = new Mock<IEventAggregator>(); Func<string, IDisposable> func = s => new MockDisposable(); var proxyDataset = CreateDataset(0, new List<Mock<IProxyDataset>>()); var project = new Mock<IProject>(); { project.Setup(p => p.BaseDataset()) .Returns(proxyDataset.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } var view = new Mock<IDatasetGraphView>(); { view.SetupSet(v => v.Model = It.IsAny<DatasetGraphModel>()) .Verifiable(); } var parameter = new DatasetGraphParameter(context.Object); var container = new Mock<IDependencyInjectionProxy>(); { container.Setup(c => c.Resolve<IContextAware>()) .Returns(context.Object); container.Setup(c => c.Resolve<ILinkToProjects>()) .Returns(projectLink.Object); container.Setup(c => c.Resolve<ITrackSteppingProgress>()) .Returns(progress.Object); container.Setup(c => c.Resolve<IEventAggregator>()) .Returns(aggregator.Object); container.Setup(c => c.Resolve<Func<string, IDisposable>>()) .Returns(func); } var presenter = new DatasetGraphPresenter(container.Object); ((IPresenter)presenter).Initialize(view.Object, parameter); Assert.AreSame(view.Object, presenter.View); Assert.AreSame(parameter, presenter.Parameter); view.VerifySet(v => v.Model = It.IsAny<DatasetGraphModel>(), Times.Once()); }
public void DeactivateDataset() { var history = new Mock<ITimeline>(); { history.Setup(h => h.Mark()) .Verifiable(); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } using (var source = new CancellationTokenSource()) { var proxy = new Mock<IProxyDataset>(); { proxy.Setup(p => p.IsActivated) .Returns(true); proxy.Setup(p => p.Deactivate()) .Returns(() => Task.Factory.StartNew( () => { }, source.Token, TaskCreationOptions.None, new CurrentThreadTaskScheduler())) .Verifiable(); } var dataset = new DatasetFacade(proxy.Object); Func<string, IDisposable> timerFunc = s => new MockDisposable(); var command = new DeactivateDatasetCommand(projectLink.Object, dataset, timerFunc); command.Execute(null); proxy.Verify(p => p.Deactivate(), Times.Once()); history.Verify(h => h.Mark(), Times.Once()); } }
public void Create() { var context = new Mock<IContextAware>(); var progressTracker = new Mock<ITrackSteppingProgress>(); var history = new Mock<ITimeline>(); { history.Setup(h => h.Mark()) .Verifiable(); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } var name = "a"; var summary = "b"; var proxy = new Mock<IProxyDataset>(); { proxy.Setup(p => p.Name) .Returns(name); proxy.Setup(p => p.Summary) .Returns(summary); proxy.Setup(p => p.IsEditMode) .Returns(false); proxy.Setup(p => p.IsActivated) .Returns(true); } var dataset = new DatasetFacade(proxy.Object); var model = new DatasetDetailModel(context.Object, progressTracker.Object, projectLink.Object, dataset); Assert.IsTrue(model.DisplayName.Contains(name)); Assert.AreEqual(name, model.Name); Assert.AreEqual(summary, model.Summary); Assert.IsTrue(model.IsLocked); Assert.IsTrue(model.IsActivated); }
public void AddNewChild() { var history = new Mock<ITimeline>(); { history.Setup(h => h.Mark()) .Verifiable(); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } var childProxy = new Mock<IProxyDataset>(); var proxy = new Mock<IProxyDataset>(); { proxy.Setup(p => p.IsValid) .Returns(true); proxy.Setup(p => p.CanBecomeParent) .Returns(true); proxy.Setup(p => p.StoredAt) .Returns(new NullPersistenceInformation()); proxy.Setup(p => p.CreateNewChild(It.IsAny<DatasetCreationInformation>())) .Returns(childProxy.Object) .Verifiable(); } var dataset = new DatasetFacade(proxy.Object); Func<string, IDisposable> func = s => new MockDisposable(); var command = new AddChildDatasetCommand(projectLink.Object, dataset, func); Assert.IsTrue(command.CanExecute(null)); command.Execute(null); proxy.Verify(p => p.CreateNewChild(It.IsAny<DatasetCreationInformation>()), Times.Once()); history.Verify(h => h.Mark(), Times.Once()); }
public void CanSaveProjectWithoutChanges() { var project = new Mock<IProject>(); var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.HasActiveProject()) .Returns(true); projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } Func<string, IDisposable> timerFunc = s => new MockDisposable(); var command = new SaveProjectCommand(projectLink.Object, timerFunc); Assert.IsFalse(command.CanExecute(null)); }
public void Name() { var context = new Mock<IContextAware>(); { context.Setup(c => c.IsSynchronized) .Returns(true); } var mockChangeSet = new Mock<IChangeSet>(); { mockChangeSet.Setup(m => m.StoreChanges()) .Verifiable(); } var history = new Mock<ITimeline>(); { history.Setup(h => h.RecordHistory()) .Returns(mockChangeSet.Object); } var project = new Mock<IProject>(); { project.SetupProperty(p => p.Name, "a") .Verify(); project.Setup(p => p.History) .Returns(history.Object); } var facade = new ProjectFacade(project.Object); var model = new ProjectDescriptionModel(context.Object, facade); var text = "b"; model.Name = text; project.VerifySet(p => p.Name = text, Times.Once()); mockChangeSet.Verify(h => h.StoreChanges(), Times.Once()); }
public void CanUndoWithMarkers() { var currentMark = new TimeMarker(10); var markers = new List<TimeMarker> { currentMark, new TimeMarker(1), }; var history = new Mock<ITimeline>(); { history.Setup(h => h.CanRollBack) .Returns(true); history.Setup(h => h.MarkersInThePast()) .Returns(markers); history.Setup(h => h.Current) .Returns(currentMark); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); projectLink.Setup(p => p.HasActiveProject()) .Returns(true); } Func<string, IDisposable> timerFunc = s => new MockDisposable(); var command = new UndoCommand(projectLink.Object, timerFunc); Assert.IsTrue(command.CanExecute(null)); }
/// <summary> /// Creates a new project. /// </summary> public void NewProject() { if (!CanCreateNewProject()) { throw new CannotCreateNewProjectException(); } var context = new CreateProjectContext(); Debug.Assert(m_Service.Contains(CreateProjectCommand.CommandId), "A command has gone missing."); m_Service.Invoke(CreateProjectCommand.CommandId, context); var project = context.Result; if (project == null) { throw new FailedToCreateProjectException(); } m_Facade = new ProjectFacade(project.Result); RaiseOnNewProjectLoaded(); }
/// <summary> /// Loads a new project from the given resource stream. /// </summary> /// <param name="persistenceInformation">The object that describes how the project was persisted.</param> public void LoadProject(IPersistenceInformation persistenceInformation) { if (!CanLoadProject()) { throw new CannotLoadProjectException(); } var context = new LoadProjectContext { LoadFrom = persistenceInformation }; Debug.Assert(m_Service.Contains(LoadProjectCommand.CommandId), "A command has gone missing."); m_Service.Invoke(LoadProjectCommand.CommandId, context); var project = context.Result; if (project == null) { throw new FailedToLoadProjectException(); } m_Facade = new ProjectFacade(project.Result); RaiseOnNewProjectLoaded(); }
public void DeleteDataset() { var history = new Mock<ITimeline>(); { history.Setup(h => h.Mark()) .Verifiable(); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } var proxy = new Mock<IProxyDataset>(); { proxy.Setup(p => p.IsValid) .Returns(true); proxy.Setup(p => p.CanBeDeleted) .Returns(true); proxy.Setup(p => p.Delete()) .Verifiable(); } var dataset = new DatasetFacade(proxy.Object); Func<string, IDisposable> func = s => new MockDisposable(); var command = new DeleteDatasetCommand(projectLink.Object, dataset, func); Assert.IsTrue(command.CanExecute(null)); command.Execute(null); proxy.Verify(p => p.Delete(), Times.Once()); history.Verify(h => h.Mark(), Times.Once()); }
public void Root() { var project = new Mock<IProject>(); { project.Setup(p => p.BaseDataset()) .Returns(new Mock<IProxyDataset>().Object); } var facade = new ProjectFacade(project.Object); var root = facade.Root(); Assert.IsNotNull(root); }
public void ReloadProject() { // Create a 'binary' tree of datasets. This should create the following tree: // X // / \ // / \ // / \ // / \ // / \ // X X // / \ / \ // / \ / \ // / \ / \ // X X X X // / \ / \ // X X X X var nodes = new List<Mock<IProxyDataset>>(); var datasets = new Queue<Tuple<Mock<IProxyDataset>, List<Mock<IProxyDataset>>>>(); var rootChildren = new List<Mock<IProxyDataset>>(); var root = CreateDataset(0, rootChildren); datasets.Enqueue(new Tuple<Mock<IProxyDataset>, List<Mock<IProxyDataset>>>(root, rootChildren)); nodes.Add(root); int count = 0; while (count < 10) { var tuple = datasets.Dequeue(); count++; var leftChildCollection = new List<Mock<IProxyDataset>>(); var leftChild = CreateDataset(count, leftChildCollection); tuple.Item2.Add(leftChild); datasets.Enqueue(new Tuple<Mock<IProxyDataset>, List<Mock<IProxyDataset>>>(leftChild, leftChildCollection)); nodes.Add(leftChild); count++; var rightChildCollection = new List<Mock<IProxyDataset>>(); var rightChild = CreateDataset(count, rightChildCollection); tuple.Item2.Add(rightChild); datasets.Enqueue(new Tuple<Mock<IProxyDataset>, List<Mock<IProxyDataset>>>(rightChild, rightChildCollection)); nodes.Add(rightChild); } var context = new Mock<IContextAware>(); { context.Setup(c => c.IsSynchronized) .Returns(true); } var tracker = new Mock<ITrackSteppingProgress>(); var project = new Mock<IProject>(); { project.Setup(p => p.BaseDataset()) .Returns(root.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } Func<DatasetFacade, DatasetModel> toModel = d => new DatasetModel(context.Object, tracker.Object, projectLink.Object, d); var model = new DatasetGraphModel(context.Object, projectFacade, toModel); var graph = model.Graph; Assert.AreEqual(nodes.Count, graph.VertexCount); var rootVertex = graph.Vertices.FirstOrDefault(d => string.Equals(d.Model.Name, 0.ToString(CultureInfo.InvariantCulture))); Assert.IsNotNull(rootVertex); var vertices = new Queue<DatasetViewVertex>(); var linearisedVertices = new List<DatasetViewVertex>(); vertices.Enqueue(rootVertex); linearisedVertices.Add(rootVertex); while (vertices.Count > 0) { var vertex = vertices.Dequeue(); var outEdges = graph.OutEdges(vertex); foreach (var edge in outEdges) { vertices.Enqueue(edge.Target); linearisedVertices.Add(edge.Target); } } Assert.That( linearisedVertices.Select(l => l.Model.Name), Is.EquivalentTo(nodes.Select(n => n.Object.Name))); }
public void AddDataset() { // Create a 'binary' tree of datasets. This should create the following tree: // X // / \ // / \ // / \ // / \ // / \ // X X var nodes = new List<Tuple<Mock<IProxyDataset>, List<Mock<IProxyDataset>>>>(); for (int i = 0; i < 3; i++) { var childCollection = new List<Mock<IProxyDataset>>(); var child = CreateDataset(i, childCollection); nodes.Add(new Tuple<Mock<IProxyDataset>, List<Mock<IProxyDataset>>>(child, childCollection)); } var context = new Mock<IContextAware>(); { context.Setup(c => c.IsSynchronized) .Returns(true); } var tracker = new Mock<ITrackSteppingProgress>(); var project = new Mock<IProject>(); { project.Setup(p => p.BaseDataset()) .Returns(nodes[0].Item1.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } Func<DatasetFacade, DatasetModel> toModel = d => new DatasetModel(context.Object, tracker.Object, projectLink.Object, d); var model = new DatasetGraphModel(context.Object, projectFacade, toModel); var graph = model.Graph; var rootVertex = graph.Vertices.FirstOrDefault(d => string.Equals(d.Model.Name, 0.ToString(CultureInfo.InvariantCulture))); var parent = nodes[0]; // First node parent.Item2.Add(nodes[1].Item1); project.Raise(p => p.OnDatasetCreated += null, EventArgs.Empty); var vertex = graph.Vertices.FirstOrDefault(d => string.Equals(d.Model.Name, 1.ToString(CultureInfo.InvariantCulture))); Assert.IsNotNull(vertex); var edges = graph.InEdges(vertex); Assert.AreEqual(1, edges.Count()); Assert.AreSame(rootVertex, edges.First().Source); // Second node parent.Item2.Add(nodes[2].Item1); project.Raise(p => p.OnDatasetCreated += null, EventArgs.Empty); vertex = graph.Vertices.FirstOrDefault(d => string.Equals(d.Model.Name, 2.ToString(CultureInfo.InvariantCulture))); Assert.IsNotNull(vertex); edges = graph.InEdges(vertex); Assert.AreEqual(1, edges.Count()); Assert.AreSame(rootVertex, edges.First().Source); }
public void UpdateSummary() { var context = new Mock<IContextAware>(); var progressTracker = new Mock<ITrackSteppingProgress>(); var mockChangeSet = new Mock<IChangeSet>(); { mockChangeSet.Setup(m => m.StoreChanges()) .Verifiable(); } var history = new Mock<ITimeline>(); { history.Setup(h => h.RecordHistory()) .Returns(mockChangeSet.Object); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } var proxy = new Mock<IProxyDataset>(); { proxy.Setup(p => p.Summary) .Verifiable(); } var dataset = new DatasetFacade(proxy.Object); var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset); var summary = "a"; model.Summary = summary; proxy.VerifySet(p => p.Summary = It.Is<string>(s => s.Equals(summary)), Times.Once()); mockChangeSet.Verify(h => h.StoreChanges(), Times.Once()); }
/// <summary> /// Initializes a new instance of the <see cref="DatasetGraphModel"/> class. /// </summary> /// <param name="context">The context that is used to execute actions on the UI thread.</param> /// <param name="facade">The project that holds the graph of datasets.</param> /// <param name="datasetModelBuilder">The function that builds <see cref="DatasetModel"/> objects.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="context"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="facade"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="datasetModelBuilder"/> is <see langword="null" />. /// </exception> public DatasetGraphModel( IContextAware context, ProjectFacade facade, Func<DatasetFacade, DatasetModel> datasetModelBuilder) : base(context) { { Enforce.Argument(() => facade); } m_Project = facade; m_Project.OnDatasetCreated += (s, e) => AddDatasetToGraph(); m_Project.OnDatasetDeleted += (s, e) => RemoveDatasetFromGraph(); m_DatasetModelBuilder = datasetModelBuilder; LayoutType = "Tree"; LayoutParameters = new SimpleTreeLayoutParameters { LayerGap = 250, VertexGap = 250, Direction = LayoutDirection.TopToBottom, }; ReloadProject(); }
/// <summary> /// Creates a new project. /// </summary> public void NewProject() { if (!CanCreateNewProject()) { throw new CannotCreateNewProjectException(); } var context = new CreateProjectContext(); Debug.Assert(m_Service.Contains(CreateProjectCommand.CommandId), "A command has gone missing."); m_Service.Invoke(CreateProjectCommand.CommandId, context); var project = context.Result; if (project == null) { throw new FailedToCreateProjectException(); } m_Facade = new ProjectFacade(project.Result); RaiseOnNewProjectLoaded(); }
public void LoadProject() { var history = new Mock<ITimeline>(); { history.Setup(h => h.Mark(It.IsAny<string>())) .Verifiable(); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); project.Setup(p => p.Save(It.IsAny<IPersistenceInformation>())) .Verifiable(); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.HasActiveProject()) .Returns(true); projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); } Func<string, IDisposable> timerFunc = s => new MockDisposable(); var command = new SaveProjectCommand(projectLink.Object, timerFunc); var persistence = new Mock<IPersistenceInformation>(); command.Execute(persistence.Object); project.Verify(p => p.Save(It.IsAny<IPersistenceInformation>()), Times.Once()); history.Verify(h => h.Mark(It.IsAny<string>()), Times.Once()); }
/// <summary> /// Unloads the current project. /// </summary> public void UnloadProject() { if (!CanUnloadProject()) { throw new CannotUnloadProjectException(); } var context = new UnloadProjectContext(); Debug.Assert(m_Service.Contains(UnloadProjectCommand.CommandId), "A command has gone missing."); m_Service.Invoke(UnloadProjectCommand.CommandId, context); m_Facade = null; RaiseOnProjectUnloaded(); }
public void Undo() { var currentMark = new TimeMarker(10); var markers = new List<TimeMarker> { currentMark, new TimeMarker(1), }; var history = new Mock<ITimeline>(); { history.Setup(h => h.CanRollBack) .Returns(true); history.Setup(h => h.MarkersInThePast()) .Returns(markers); history.Setup(h => h.Current) .Returns(currentMark); history.Setup(h => h.RollBackTo(It.IsAny<TimeMarker>(), It.IsAny<TimelineTraveller>())) .Verifiable(); } var project = new Mock<IProject>(); { project.Setup(p => p.History) .Returns(history.Object); } var projectFacade = new ProjectFacade(project.Object); var projectLink = new Mock<ILinkToProjects>(); { projectLink.Setup(p => p.ActiveProject()) .Returns(projectFacade); projectLink.Setup(p => p.HasActiveProject()) .Returns(true); } Func<string, IDisposable> timerFunc = s => new MockDisposable(); var command = new UndoCommand(projectLink.Object, timerFunc); command.Execute(null); history.Verify(h => h.RollBackTo(It.IsAny<TimeMarker>(), It.IsAny<TimelineTraveller>()), Times.Once()); }
public void SaveProject() { var persistence = new Mock<IPersistenceInformation>(); var project = new Mock<IProject>(); { project.Setup(p => p.Save(It.IsAny<IPersistenceInformation>())) .Callback<IPersistenceInformation>(info => Assert.AreSame(persistence.Object, info)); } var facade = new ProjectFacade(project.Object); facade.SaveProject(persistence.Object); }
public void Summary() { var project = new Mock<IProject>(); { project.SetupProperty(p => p.Summary); } var facade = new ProjectFacade(project.Object); var summary = "text"; facade.Summary = summary; Assert.AreEqual(summary, facade.Summary); }
public void OnSummaryChange() { var context = new Mock<IContextAware>(); { context.Setup(c => c.IsSynchronized) .Returns(true); } var project = new Mock<IProject>(); var facade = new ProjectFacade(project.Object); var model = new ProjectDescriptionModel(context.Object, facade); var propertyChangedWasRaised = 0; var properties = new List<string>(); model.PropertyChanged += (s, e) => { propertyChangedWasRaised++; properties.Add(e.PropertyName); }; var text = "a"; project.Raise(p => p.OnSummaryChanged += null, new ValueChangedEventArgs<string>(text)); Assert.AreEqual(1, propertyChangedWasRaised); Assert.That( properties, Is.EquivalentTo( new List<string> { "Summary", })); }