/// <summary>
/// Initializes a new instance of the <see cref="DatasetDetailModel"/> class.
/// </summary>
/// <param name="context">The context that is used to execute actions on the UI thread.</param>
/// <param name="progressTracker">The object that handles the progress notifications for the applications.</param>
/// <param name="project">The project that holds all the data.</param>
/// <param name="dataset">The dataset.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="context"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="progressTracker"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="project"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="dataset"/> is <see langword="null" />.
/// </exception>
public DatasetDetailModel(IContextAware context, ITrackSteppingProgress progressTracker, ILinkToProjects project, DatasetFacade dataset)
: base(context)
{
{
Lokad.Enforce.Argument(() => progressTracker);
Lokad.Enforce.Argument(() => project);
Lokad.Enforce.Argument(() => dataset);
}
m_ProgressTracker = progressTracker;
m_Project = project;
m_Dataset = dataset;
m_Dataset.OnNameChanged += (s, e) =>
{
Notify(() => Name);
Notify(() => DisplayName);
};
m_Dataset.OnSummaryChanged += (s, e) => Notify(() => Summary);
m_Dataset.OnProgressOfCurrentAction += HandleDatasetProgress;
m_Dataset.OnDeactivated += (s, e) =>
{
Notify(() => IsActivated);
Notify(() => Endpoint);
RaiseOnDeactivated();
};
}
/// <summary>
/// Initializes a new instance of the <see cref="DatasetDetailModel"/> class.
/// </summary>
/// <param name="context">The context that is used to execute actions on the UI thread.</param>
/// <param name="progressTracker">The object that handles the progress notifications for the applications.</param>
/// <param name="project">The project that holds all the data.</param>
/// <param name="dataset">The dataset.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="context"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="progressTracker"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="project"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="dataset"/> is <see langword="null" />.
/// </exception>
public DatasetDetailModel(IContextAware context, ITrackSteppingProgress progressTracker, ILinkToProjects project, DatasetFacade dataset)
: base(context)
{
{
Lokad.Enforce.Argument(() => progressTracker);
Lokad.Enforce.Argument(() => project);
Lokad.Enforce.Argument(() => dataset);
}
m_ProgressTracker = progressTracker;
m_Project = project;
m_Dataset = dataset;
m_Dataset.OnNameChanged += (s, e) =>
{
Notify(() => Name);
Notify(() => DisplayName);
};
m_Dataset.OnSummaryChanged += (s, e) => Notify(() => Summary);
m_Dataset.OnProgressOfCurrentAction += HandleDatasetProgress;
m_Dataset.OnDeactivated += (s, e) =>
{
Notify(() => IsActivated);
Notify(() => Endpoint);
RaiseOnDeactivated();
};
}
public void OnNameChange()
{
var context = new Mock <IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock <ITrackSteppingProgress>();
var projectLink = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var wasRaised = 0;
var properties = new List <string>();
model.PropertyChanged += (s, e) =>
{
wasRaised++;
properties.Add(e.PropertyName);
};
proxy.Raise(p => p.OnNameChanged += null, new ValueChangedEventArgs <string>("a"));
Assert.AreEqual(1, wasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List <string>
{
"Name",
}));
}
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());
}
/// <summary>
/// Called when the dataset should be activated.
/// </summary>
/// <param name="projectFacade">The object that contains the methods that allow interaction with the project system.</param>
/// <param name="dataset">The dataset.</param>
/// <param name="selector">
/// The function that is used to select the most suitable machine to distribute the dataset to.
/// </param>
/// <param name="timer">The function that creates and stores timing intervals.</param>
private static void OnActivate(
ILinkToProjects projectFacade,
DatasetFacade dataset,
Func <IEnumerable <DistributionSuggestion>, SelectedProposal> selector,
Func <string, IDisposable> timer)
{
// If there is no application facade, then we're in
// designer mode, or something else silly.
if (dataset == null)
{
return;
}
if (dataset.IsActivated || !dataset.CanActivate)
{
return;
}
using (timer("Loading dataset onto machine"))
{
var source = new CancellationTokenSource();
dataset.Activate(
DistributionLocations.All,
selector,
source.Token)
.ContinueWith(t => source.Dispose());
projectFacade.ActiveProject().History.Mark();
}
}
public void OnSummaryChange()
{
var context = new Mock <IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock <ITrackSteppingProgress>();
var projectLink = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var wasRaised = false;
model.PropertyChanged += (s, e) =>
{
wasRaised = true;
Assert.AreEqual("Summary", e.PropertyName);
};
proxy.Raise(p => p.OnSummaryChanged += null, new ValueChangedEventArgs <string>("a"));
Assert.IsTrue(wasRaised);
}
private ActivateDatasetCommand CreateActivateDatasetCommand(
ILinkToProjects projectFacade,
DatasetFacade dataset,
Func <string, IDisposable> timer)
{
var context = m_Container.Resolve <IContextAware>();
Func <IEnumerable <DistributionSuggestion>, SelectedProposal> selector =
c =>
{
var presenter = (IPresenter)m_Container.Resolve(typeof(MachineSelectorPresenter));
var view = m_Container.Resolve(presenter.ViewType) as IMachineSelectorView;
presenter.Initialize(view, new MachineSelectorParameter(context, c));
var window = view as Window;
window.Owner = Application.Current.MainWindow;
if (window.ShowDialog() ?? false)
{
return(new SelectedProposal(view.Model.SelectedPlan));
}
return(new SelectedProposal());
};
var command = m_Container.Resolve <ActivateDatasetCommand>(
new TypedParameter(typeof(ILinkToProjects), projectFacade),
new TypedParameter(typeof(DatasetFacade), dataset),
new TypedParameter(typeof(Func <IEnumerable <DistributionSuggestion>, SelectedProposal>), selector),
new TypedParameter(typeof(SystemDiagnostics), timer));
return(command);
}
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 ActivateDatasetCommand(
ILinkToProjects projectFacade,
DatasetFacade dataset,
Func <IEnumerable <DistributionSuggestion>, SelectedProposal> selector,
Func <string, IDisposable> timer)
: base(obj => OnActivate(projectFacade, dataset, selector, timer), obj => CanActivate(dataset))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="DatasetDetailParameter"/> class.
/// </summary>
/// <param name="context">The context that is used to execute actions on the UI thread.</param>
/// <param name="dataset">The dataset that should be passed to the presenter.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="context"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="dataset"/> is <see langword="null" />.
/// </exception>
public DatasetDetailParameter(IContextAware context, DatasetFacade dataset)
: base(context)
{
{
Lokad.Enforce.Argument(() => dataset);
}
m_Dataset = dataset;
}
/// <summary>
/// Initializes a new instance of the <see cref="DatasetDetailParameter"/> class.
/// </summary>
/// <param name="context">The context that is used to execute actions on the UI thread.</param>
/// <param name="dataset">The dataset that should be passed to the presenter.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="context"/> is <see langword="null" />.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="dataset"/> is <see langword="null" />.
/// </exception>
public DatasetDetailParameter(IContextAware context, DatasetFacade dataset)
: base(context)
{
{
Lokad.Enforce.Argument(() => dataset);
}
m_Dataset = dataset;
}
public void Create()
{
var context = new Mock <IContextAware>();
var proxy = new Mock <IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var parameter = new DatasetDetailParameter(context.Object, dataset);
Assert.AreSame(dataset, parameter.Dataset);
}
private static bool CanAddNewChild(DatasetFacade datasetFacade)
{
// If there is no dataset facade, then we're in
// designer mode, or something else silly.
if (datasetFacade == null)
{
return(false);
}
return(datasetFacade.IsValid ? datasetFacade.CanBecomeParent : false);
}
private static bool CanDeleteDataset(DatasetFacade datasetFacade)
{
// If there is no dataset facade, then we're in
// designer mode, or something else silly.
if (datasetFacade == null)
{
return(false);
}
return(datasetFacade.IsValid ? datasetFacade.CanBeDeleted : false);
}
/// <summary>
/// Switches the dataset to the edit mode.
/// </summary>
/// <param name="dataset">The dataset.</param>
private static void OnSwitchToEditMode(DatasetFacade dataset)
{
// If there is no facade then we're in design mode or something
// else weird.
if (dataset == null)
{
return;
}
dataset.SwitchToEditMode();
}
private static bool CanActivate(DatasetFacade dataset)
{
// If there is no application facade, then we're in
// designer mode, or something else silly.
if (dataset == null)
{
return(false);
}
return(!dataset.IsActivated && dataset.CanActivate);
}
public void CanSwitchWhileDatasetIsInEditMode()
{
var proxy = new Mock<IProxyDataset>();
{
proxy.Setup(p => p.IsEditMode)
.Returns(false);
}
var dataset = new DatasetFacade(proxy.Object);
var command = new SwitchDatasetToExecutingModeCommand(dataset);
Assert.IsFalse(command.CanExecute(null));
}
private static DatasetDetailParameter CreateInstance()
{
var context = new Mock <IContextAware>();
var proxy = new Mock <IProxyDataset>();
{
proxy.Setup(p => p.Equals(It.IsAny <IProxyDataset>()))
.Returns <IProxyDataset>(other => ReferenceEquals(other, proxy.Object));
}
var dataset = new DatasetFacade(proxy.Object);
return(new DatasetDetailParameter(context.Object, dataset));
}
public void OnActivated()
{
var context = new Mock <IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock <ITrackSteppingProgress>();
{
progressTracker.Setup(p => p.StopTracking())
.Verifiable();
}
var projectLink = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var propertyChangedWasRaised = 0;
var properties = new List <string>();
model.PropertyChanged += (s, e) =>
{
propertyChangedWasRaised++;
properties.Add(e.PropertyName);
};
var onLoadedWasRaised = false;
model.OnActivated += (s, e) =>
{
onLoadedWasRaised = true;
};
proxy.Raise(p => p.OnActivated += null, EventArgs.Empty);
Assert.AreEqual(4, propertyChangedWasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List <string>
{
"IsActivated",
"RunsOn",
"Progress",
"ProgressDescription",
}));
Assert.IsTrue(onLoadedWasRaised);
progressTracker.Verify(p => p.StopTracking(), Times.Once());
}
public void CanSwitchWhileDatasetIsInEditMode()
{
var proxy = new Mock <IProxyDataset>();
{
proxy.Setup(p => p.IsEditMode)
.Returns(true);
}
var dataset = new DatasetFacade(proxy.Object);
var command = new SwitchDatasetToEditModeCommand(dataset);
Assert.IsFalse(command.CanExecute(null));
}
/// <summary>
/// Initializes a new instance of the <see cref="ScriptBackEndDatasetFacade"/> class.
/// </summary>
/// <param name="facade">The object that stores information about the dataset.</param>
/// <exception cref="ArgumentNullException">
/// Thrown if <paramref name="facade"/> is <see langword="null" />.
/// </exception>
public ScriptBackEndDatasetFacade(DatasetFacade facade)
{
{
Enforce.Argument(() => facade);
}
m_Dataset = facade;
m_Dataset.OnInvalidate += (s, e) => RaiseOnInvalidate();
m_Dataset.OnProgressOfCurrentAction += (s, e) => RaiseOnProgressOfCurrentAction(e.Progress, e.Description, e.HasErrors);
m_Dataset.OnActivated += (s, e) => RaiseOnActivated();
m_Dataset.OnDeactivated += (s, e) => RaiseOnDeactivated();
m_Dataset.OnNameChanged += (s, e) => RaiseOnNameChanged();
m_Dataset.OnSummaryChanged += (s, e) => RaiseOnSummaryChanged();
}
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 SwitchToEditMode()
{
var proxy = new Mock<IProxyDataset>();
{
proxy.Setup(p => p.SwitchToExecutingMode())
.Verifiable();
}
var dataset = new DatasetFacade(proxy.Object);
var command = new SwitchDatasetToExecutingModeCommand(dataset);
command.Execute(null);
proxy.Verify(p => p.SwitchToExecutingMode(), Times.Once());
}
/// <summary>
/// Called when a new child dataset should be added.
/// </summary>
/// <param name="projectFacade">The object that contains the methods that allow interaction with the project system.</param>
/// <param name="datasetFacade">The object that contains the methods that allow interaction with a dataset.</param>
/// <param name="timer">The function that creates and stores timing intervals.</param>
private static void OnAddNewChild(ILinkToProjects projectFacade, DatasetFacade datasetFacade, Func <string, IDisposable> timer)
{
// If there is no dataset facade, then we're in
// designer mode, or something else silly.
if (datasetFacade == null)
{
return;
}
using (timer("Add dataset to graph"))
{
datasetFacade.AddChild();
projectFacade.ActiveProject().History.Mark();
}
}
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 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 SwitchToEditMode()
{
var proxy = new Mock <IProxyDataset>();
{
proxy.Setup(p => p.SwitchToEditMode())
.Verifiable();
}
var dataset = new DatasetFacade(proxy.Object);
var command = new SwitchDatasetToEditModeCommand(dataset);
command.Execute(null);
proxy.Verify(p => p.SwitchToEditMode(), Times.Once());
}
public void CanDeleteDatasetWithInvalidDatasetFacade()
{
var project = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
{
proxy.Setup(p => p.IsValid)
.Returns(false);
}
var dataset = new DatasetFacade(proxy.Object);
Func<string, IDisposable> func = s => new MockDisposable();
var command = new DeleteDatasetCommand(project.Object, dataset, func);
Assert.IsFalse(command.CanExecute(null));
}
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 CanAddNewChildWithInvalidDatasetFacade()
{
var project = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
{
proxy.Setup(p => p.IsValid)
.Returns(false);
}
var dataset = new DatasetFacade(proxy.Object);
Func <string, IDisposable> func = s => new MockDisposable();
var command = new AddChildDatasetCommand(project.Object, dataset, func);
Assert.IsFalse(command.CanExecute(null));
}
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 CanDeactivateWithDeactivatedDataset()
{
var project = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
{
proxy.Setup(p => p.IsActivated)
.Returns(false);
}
var dataset = new DatasetFacade(proxy.Object);
Func <string, IDisposable> timerFunc = s => new MockDisposable();
var command = new DeactivateDatasetCommand(project.Object, dataset, timerFunc);
Assert.IsFalse(command.CanExecute(null));
}
public void UpdateName()
{
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.Name)
.Verifiable();
}
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var name = "a";
model.Name = name;
proxy.VerifySet(p => p.Name = It.Is <string>(s => s.Equals(name)), Times.Once());
mockChangeSet.Verify(h => h.StoreChanges(), Times.Once());
}
public void CanDeleteDatasetWithDatasetNotAllowedToBeDeleted()
{
var project = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
{
proxy.Setup(p => p.IsValid)
.Returns(true);
proxy.Setup(p => p.CanBeDeleted)
.Returns(false);
}
var dataset = new DatasetFacade(proxy.Object);
Func <string, IDisposable> func = s => new MockDisposable();
var command = new DeleteDatasetCommand(project.Object, dataset, func);
Assert.IsFalse(command.CanExecute(null));
}
public void OnDeactivate()
{
var context = new Mock <IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock <ITrackSteppingProgress>();
var projectLink = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetDetailModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var propertyChangedWasRaised = 0;
var properties = new List <string>();
model.PropertyChanged += (s, e) =>
{
propertyChangedWasRaised++;
properties.Add(e.PropertyName);
};
var onUnloadedWasRaised = false;
model.OnDeactivated += (s, e) =>
{
onUnloadedWasRaised = true;
};
proxy.Raise(p => p.OnDeactivated += null, EventArgs.Empty);
Assert.AreEqual(2, propertyChangedWasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List <string>
{
"IsActivated",
"Endpoint",
}));
Assert.IsTrue(onUnloadedWasRaised);
}
public void CanActivateWithActivatedDataset()
{
var project = new Mock <ILinkToProjects>();
var proxy = new Mock <IProxyDataset>();
{
proxy.Setup(p => p.IsActivated)
.Returns(true);
}
var dataset = new DatasetFacade(proxy.Object);
Func <IEnumerable <DistributionSuggestion>, SelectedProposal> selectionFunc = suggestions => null;
Func <string, IDisposable> timerFunc = s => new MockDisposable();
var command = new ActivateDatasetCommand(project.Object, dataset, selectionFunc, timerFunc);
Assert.IsFalse(command.CanExecute(null));
}
/// <summary>
/// Creates a new dataset model.
/// </summary>
/// <param name="dataset">The dataset for the new model.</param>
/// <returns>
/// The dataset model for the given facade.
/// </returns>
private DatasetModel CreateModel(DatasetFacade dataset)
{
var context = m_Container.Resolve <IContextAware>();
var projectFacade = m_Container.Resolve <ILinkToProjects>();
var progressTracker = m_Container.Resolve <ITrackSteppingProgress>();
var timer = m_Container.Resolve <Func <string, IDisposable> >();
var eventAggregator = m_Container.Resolve <IEventAggregator>();
var result = new DatasetModel(context, progressTracker, projectFacade, dataset)
{
NewChildDatasetCommand = new AddChildDatasetCommand(projectFacade, dataset, timer),
DeleteDatasetCommand = new DeleteDatasetCommand(projectFacade, dataset, timer),
ActivateDatasetCommand = CreateActivateDatasetCommand(projectFacade, dataset, timer),
DeactivateDatasetCommand = new DeactivateDatasetCommand(projectFacade, dataset, timer),
ShowDetailViewCommand = new ShowDatasetDetailViewCommand(context, eventAggregator, dataset),
};
return(result);
}
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 OnActivated()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock<ITrackSteppingProgress>();
var projectLink = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
{
proxy.Setup(p => p.IsActivated)
.Returns(true);
}
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var vertex = new DatasetViewVertex(context.Object, model);
var propertyChangedWasRaised = 0;
var properties = new List<string>();
vertex.PropertyChanged += (s, e) =>
{
propertyChangedWasRaised++;
properties.Add(e.PropertyName);
};
proxy.Raise(p => p.OnActivated += null, EventArgs.Empty);
Assert.AreEqual(1, propertyChangedWasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List<string>
{
"IsDatasetActivated",
}));
Assert.IsTrue(vertex.IsDatasetActivated);
}
public void Convert()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock<ITrackSteppingProgress>();
var projectLink = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
{
proxy.Setup(p => p.IsActivated)
.Returns(true);
}
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var vertex = new DatasetViewVertex(context.Object, model);
var converter = new DatasetViewVertexToDatasetModelConverter();
var obj = converter.Convert(vertex, null, null, null) as DatasetModel;
Assert.AreSame(model, obj);
}
public void Initialize()
{
var context = new Mock<IContextAware>();
var project = new Mock<ILinkToProjects>();
var progress = new Mock<ITrackSteppingProgress>();
var aggregator = new Mock<IEventAggregator>();
var view = new Mock<IDatasetDetailView>();
{
view.SetupSet(v => v.Model = It.IsAny<DatasetDetailModel>())
.Verifiable();
}
var proxy = new Mock<IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var parameter = new DatasetDetailParameter(context.Object, dataset);
var container = new Mock<IDependencyInjectionProxy>();
{
container.Setup(c => c.Resolve<IContextAware>())
.Returns(context.Object);
container.Setup(c => c.Resolve<ILinkToProjects>())
.Returns(project.Object);
container.Setup(c => c.Resolve<ITrackSteppingProgress>())
.Returns(progress.Object);
container.Setup(c => c.Resolve<CloseViewCommand>(It.IsAny<Autofac.Core.Parameter[]>()))
.Returns(new CloseViewCommand(aggregator.Object, "a", parameter));
}
var presenter = new DatasetDetailPresenter(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<DatasetDetailModel>(), Times.Once());
}
public void CanActivateWithActivatedDataset()
{
var project = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
{
proxy.Setup(p => p.IsActivated)
.Returns(true);
}
var dataset = new DatasetFacade(proxy.Object);
Func<IEnumerable<DistributionSuggestion>, SelectedProposal> selectionFunc = suggestions => null;
Func<string, IDisposable> timerFunc = s => new MockDisposable();
var command = new ActivateDatasetCommand(project.Object, dataset, selectionFunc, timerFunc);
Assert.IsFalse(command.CanExecute(null));
}
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 OnSummaryChange()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock<ITrackSteppingProgress>();
var projectLink = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var wasRaised = false;
model.PropertyChanged += (s, e) =>
{
wasRaised = true;
Assert.AreEqual("Summary", e.PropertyName);
};
proxy.Raise(p => p.OnSummaryChanged += null, new ValueChangedEventArgs<string>("a"));
Assert.IsTrue(wasRaised);
}
public void OnDeactivate()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock<ITrackSteppingProgress>();
var projectLink = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetDetailModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var propertyChangedWasRaised = 0;
var properties = new List<string>();
model.PropertyChanged += (s, e) =>
{
propertyChangedWasRaised++;
properties.Add(e.PropertyName);
};
var onUnloadedWasRaised = false;
model.OnDeactivated += (s, e) =>
{
onUnloadedWasRaised = true;
};
proxy.Raise(p => p.OnDeactivated += null, EventArgs.Empty);
Assert.AreEqual(2, propertyChangedWasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List<string>
{
"IsActivated",
"Endpoint",
}));
Assert.IsTrue(onUnloadedWasRaised);
}
public void OnNameChange()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock<ITrackSteppingProgress>();
var projectLink = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var wasRaised = 0;
var properties = new List<string>();
model.PropertyChanged += (s, e) =>
{
wasRaised++;
properties.Add(e.PropertyName);
};
proxy.Raise(p => p.OnNameChanged += null, new ValueChangedEventArgs<string>("a"));
Assert.AreEqual(1, wasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List<string>
{
"Name",
}));
}
public void OnActivated()
{
var context = new Mock<IContextAware>();
{
context.Setup(c => c.IsSynchronized)
.Returns(true);
}
var progressTracker = new Mock<ITrackSteppingProgress>();
{
progressTracker.Setup(p => p.StopTracking())
.Verifiable();
}
var projectLink = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
var propertyChangedWasRaised = 0;
var properties = new List<string>();
model.PropertyChanged += (s, e) =>
{
propertyChangedWasRaised++;
properties.Add(e.PropertyName);
};
var onLoadedWasRaised = false;
model.OnActivated += (s, e) =>
{
onLoadedWasRaised = true;
};
proxy.Raise(p => p.OnActivated += null, EventArgs.Empty);
Assert.AreEqual(4, propertyChangedWasRaised);
Assert.That(
properties,
Is.EquivalentTo(
new List<string>
{
"IsActivated",
"RunsOn",
"Progress",
"ProgressDescription",
}));
Assert.IsTrue(onLoadedWasRaised);
progressTracker.Verify(p => p.StopTracking(), Times.Once());
}
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());
}
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 CanAddNewChildWithDatasetNotAllowedToBecomeParent()
{
var project = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
{
proxy.Setup(p => p.IsValid)
.Returns(true);
proxy.Setup(p => p.CanBecomeParent)
.Returns(false);
}
var dataset = new DatasetFacade(proxy.Object);
Func<string, IDisposable> func = s => new MockDisposable();
var command = new AddChildDatasetCommand(project.Object, dataset, func);
Assert.IsFalse(command.CanExecute(null));
}
public void OnProgress()
{
var context = new Mock<IContextAware>();
var progressTracker = new Mock<ITrackSteppingProgress>();
{
progressTracker.Setup(p => p.StartTracking())
.Verifiable();
progressTracker.Setup(p => p.StopTracking())
.Verifiable();
progressTracker.Setup(p => p.UpdateProgress(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<bool>()))
.Verifiable();
}
var projectLink = new Mock<ILinkToProjects>();
var proxy = new Mock<IProxyDataset>();
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
// Verify here to indicate that we do really need this instance.
Assert.IsNotNull(model);
proxy.Raise(p => p.OnProgressOfCurrentAction += null, new ProgressEventArgs(0, "a", false));
progressTracker.Verify(p => p.StartTracking(), Times.Once());
progressTracker.Verify(p => p.UpdateProgress(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Once());
progressTracker.Verify(p => p.StopTracking(), Times.Never());
proxy.Raise(p => p.OnProgressOfCurrentAction += null, new ProgressEventArgs(50, "b", false));
progressTracker.Verify(p => p.StartTracking(), Times.Once());
progressTracker.Verify(p => p.UpdateProgress(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Exactly(2));
progressTracker.Verify(p => p.StopTracking(), Times.Never());
proxy.Raise(p => p.OnProgressOfCurrentAction += null, new ProgressEventArgs(100, "c", false));
progressTracker.Verify(p => p.StartTracking(), Times.Once());
progressTracker.Verify(p => p.UpdateProgress(It.IsAny<int>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Exactly(3));
progressTracker.Verify(p => p.StopTracking(), Times.Once());
}
