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 GetProject_ShouldNotReturnProject()
{ //arrange
var ProjectIdToBeQueried = 1000;
var mockProjectRepository = new Mock <IProjectRepository>().Object;
Mock.Get <IProjectRepository>(mockProjectRepository).Setup(r => r.Get(ProjectIdToBeQueried));
var projectFacade = new ProjectFacade(mockProjectRepository);
var projectController = new ProjectController(projectFacade);
//act
var result = projectController.GetProject(ProjectIdToBeQueried) as OkNegotiatedContentResult <ProjectDto>;
//assert
Assert.AreEqual(null, null);
}
public void Delete_ShouldNotDeleteWhenProjectNotFound()
{
//arrange
var ProjectIdToBDeleted = 4;
var mockProjectRepository = new Mock <IProjectRepository>().Object;
Mock.Get <IProjectRepository>(mockProjectRepository).Setup(r => r.Get(ProjectIdToBDeleted));
var projectFacade = new ProjectFacade(mockProjectRepository);
var projectController = new ProjectController(projectFacade);
//act
var result = projectController.Delete(ProjectIdToBDeleted) as OkNegotiatedContentResult <bool>;
//assert
Assert.Null(result);
}
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.IsActivated)
.Returns(true);
}
var dataset = new DatasetFacade(proxy.Object);
var model = new DatasetModel(context.Object, progressTracker.Object, projectLink.Object, dataset);
Assert.AreEqual(name, model.Name);
Assert.AreEqual(summary, model.Summary);
Assert.IsTrue(model.IsActivated);
}
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 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 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 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 Summary()
{
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.Summary, "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.Summary = text;
project.VerifySet(p => p.Summary = 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));
}
public void GetProject_ShouldReturnCorrectProject()
{
//arrange
var ProjectIdToBeQueried = 1;
var testProjects = GetTestProjects();
var mockProjectRepository = new Mock <IProjectRepository>().Object;
Mock.Get <IProjectRepository>(mockProjectRepository).Setup(r => r.Get(ProjectIdToBeQueried)).Returns(testProjects.First(u => u.Id == ProjectIdToBeQueried));
var projectFacade = new ProjectFacade(mockProjectRepository);
var projectController = new ProjectController(projectFacade);
var expectetProject = testProjects.First(u => u.Id == ProjectIdToBeQueried);
//act
var result = projectController.GetProject(ProjectIdToBeQueried) as OkNegotiatedContentResult <ProjectDto>;
//assert
Assert.AreEqual(expectetProject.Name, result.Content.Name);
Assert.AreEqual(expectetProject.Priority, result.Content.Priority);
Assert.AreEqual(expectetProject.ManagerId, result.Content.ManagerId);
}
public void Delete_ShouldDeleteCorrectProject()
{
//arrange
var testProjects = GetTestProjects();
var ProjectIdToBDeleted = 4;
var Project = testProjects.First(u => u.Id == ProjectIdToBDeleted);
var mockProjectRepository = new Mock <IProjectRepository>().Object;
Mock.Get <IProjectRepository>(mockProjectRepository).Setup(r => r.Get(ProjectIdToBDeleted)).Returns(Project);
Mock.Get <IProjectRepository>(mockProjectRepository).Setup(r => r.Remove(Project));
var projectFacade = new ProjectFacade(mockProjectRepository);
var projectController = new ProjectController(projectFacade);
//act
var result = projectController.Delete(ProjectIdToBDeleted) as OkNegotiatedContentResult <bool>;
//assert
Assert.True(result.Content);
}
public void QueryProjects_ShouldReturnAllProjects()
{
//arrange
var testProjects = GetTestProjects();
var queryResult = new FilterResult <Project>()
{
Data = testProjects, Total = testProjects.Count()
};
var mockProjectRepository = new Mock <IProjectRepository>().Object;
Mock.Get <IProjectRepository>(mockProjectRepository).Setup(r => r.Query(It.IsAny <FilterState>())).Returns(queryResult);
var projectFacade = new ProjectFacade(mockProjectRepository);
var projectController = new ProjectController(projectFacade);
var filterState = new FilterState();
//act : no filters
var x = projectController.Query(filterState);
var result = x as OkNegotiatedContentResult <FilterResult <ProjectDto> >;
//assert
Assert.AreEqual(testProjects.Count(), result.Content.Total);
}
public void QueryProjects_ShouldReturnTaskWithPriorityGreaterThanAndEqualToZero()
{
//arrange
var testProjects = GetTestProjects().Where(p => p.Priority >= 0);
var queryResult = new FilterResult <Project>()
{
Data = testProjects, Total = testProjects.Count()
};
var mockProjectRepository = new Mock <IProjectRepository>().Object;
Mock.Get <IProjectRepository>(mockProjectRepository).Setup(r => r.Query(It.IsAny <FilterState>())).Returns(queryResult);
var projectFacade = new ProjectFacade(mockProjectRepository);
var projectController = new ProjectController(projectFacade);
var thisAssembly = Assembly.GetExecutingAssembly();
var jsonFilePath = Path.Combine(Directory.GetParent(thisAssembly.Location).FullName, @"TestData\FilerStat.Json");
var fileStatString = File.ReadAllText(jsonFilePath);
var filterState = fileStatString.ToObject <FilterState>();
var result = projectController.Query(filterState) as OkNegotiatedContentResult <FilterResult <ProjectDto> >;
//assert
Assert.True(result.Content.Data.All(t => t.Priority >= 0));
}
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 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());
}
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 ProjectController(ProjectFacade projectFacade)
{
this.projectFacade = projectFacade;
}
public ReportController(ProjectFacade projectFacade, TaskFacade taskFacade)
{
this.projectFacade = projectFacade;
this.taskFacade = taskFacade;
}
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);
}
