public void ClipNotEnabledIfPolygonsCountIsNotEqualTwo()
{
var mockGenerator = new Mock <PolygonGenerator>();
var mockProvider = new Mock <PolygonGeneratorProvider>();
mockProvider.Setup(x => x.GetGenerators()).Returns(new[] { mockGenerator.Object });
var mockClipper = new Mock <PolygonClipper>();
var vm = new PolygonManagementViewModel(mockProvider.Object, null, mockClipper.Object);
// Polygons initially empty --> command must be disabled
Assert.False(vm.ClipPolygonsCommand.CanExecute());
vm.GenerateAndAddPolygonCommand.Execute();
Assert.False(vm.ClipPolygonsCommand.CanExecute());
var receivedExecuteChanged = false;
vm.ClipPolygonsCommand.CanExecuteChanged += (_, __) => receivedExecuteChanged = true;
vm.GenerateAndAddPolygonCommand.Execute();
Assert.True(vm.ClipPolygonsCommand.CanExecute());
Assert.True(receivedExecuteChanged);
receivedExecuteChanged = false;
vm.GenerateAndAddPolygonCommand.Execute();
Assert.False(vm.ClipPolygonsCommand.CanExecute());
Assert.True(receivedExecuteChanged);
}
public void CannotGeneratePolygonWithoutGenerator()
{
using var vm = new PolygonManagementViewModel(Array.Empty <IPolygonGenerator>());
// vm.SelectedPolygonGenerator is initially null
Assert.False(vm.GenerateAndAddPolygonCommand.CanExecute());
}
public MainWindow(PolygonManagementViewModel viewModel)
{
InitializeComponent();
//this.DataContext = this;
this.DataContext = viewModel;
//((PolygonManagementViewModel)this.DataContext).SelectedPolygonGenerator =
// new RandomPolygonGenerator();
}
public void FillPolygonGeneratorsFromContainer()
{
using var vm = new PolygonManagementViewModel(new[] { new DummyGenerator() });
Assert.Single(vm.Generators);
var generator = vm.Generators.First();
Assert.Equal("Dummy", generator.FriendlyName);
Assert.IsType <DummyGenerator>(generator.Generator);
Assert.Equal(vm.SelectedPolygonGenerator, generator.Generator);
}
public void EnsureSuccessMessageBoxOnGenerate()
{
var mockDialogHandler = new Mock <IDialogHandler>();
var vm = new PolygonManagementViewModel(null, mockDialogHandler.Object);
vm.SelectedPolygonGenerator = GetMockGenerator().Object;
vm.GenerateAndAddPolygonCommand.Execute();
// This is how you would verify that the message box has been triggered:
// mockDialogHandler.Verify(x => x.ShowMessageBox(It.IsAny<string>()), Times.Once);
}
public void CalculateAreaForSelectedPolygon()
{
(var tcs, var mockCalculator) = GetMockAreaCalculator();
using var vm = new PolygonManagementViewModel(Array.Empty <IPolygonGenerator>(), mockCalculator.Object)
{
SelectedPolygon = new Polygon()
};
var receivedEvents = new HashSet <string>();
vm.PropertyChanged += (_, ea) => receivedEvents.Add(ea.PropertyName);
var calculate = false;
var cancel = false;
vm.CalculateAreaForSelectedPolygonCommand.CanExecuteChanged += (_, __) => calculate = true;
vm.CancelAreaCalculationCommand.CanExecuteChanged += (_, __) => cancel = true;
// Check state before calculation starts
Assert.True(vm.CalculateAreaForSelectedPolygonCommand.CanExecute());
Assert.False(vm.IsCalculatingArea);
Assert.False(vm.CancelAreaCalculationCommand.CanExecute());
Assert.Null(vm.Area);
Assert.False(vm.IsAreaAvailable);
// Start calculation
vm.CalculateAreaForSelectedPolygonCommand.Execute();
// Check state after starting the calculation
Assert.True(vm.IsCalculatingArea);
Assert.Contains(nameof(PolygonManagementViewModel.IsCalculatingArea), receivedEvents);
Assert.False(vm.CalculateAreaForSelectedPolygonCommand.CanExecute());
Assert.True(calculate);
Assert.True(vm.CancelAreaCalculationCommand.CanExecute());
Assert.True(cancel);
// Simulate finishing of calculation
calculate = cancel = false;
receivedEvents.Clear();
tcs.SetResult(42d);
// Check state after calculation
Assert.True(vm.CalculateAreaForSelectedPolygonCommand.CanExecute());
Assert.True(calculate);
Assert.False(vm.CancelAreaCalculationCommand.CanExecute());
Assert.True(cancel);
Assert.False(vm.IsCalculatingArea);
Assert.Contains(nameof(PolygonManagementViewModel.IsCalculatingArea), receivedEvents);
Assert.Equal(42d, vm.Area);
Assert.Contains(nameof(PolygonManagementViewModel.Area), receivedEvents);
Assert.True(vm.IsAreaAvailable);
Assert.Contains(nameof(PolygonManagementViewModel.IsAreaAvailable), receivedEvents);
}
public void SendCommandEventWhenGeneratorGetsSelected()
{
using var vm = new PolygonManagementViewModel(Array.Empty <IPolygonGenerator>());
var receivedGenerateCommandChanged = false;
vm.GenerateAndAddPolygonCommand.CanExecuteChanged +=
(_, __) => receivedGenerateCommandChanged = true;
vm.SelectedPolygonGenerator = GetMockGenerator().Object;
Assert.True(receivedGenerateCommandChanged);
Assert.True(vm.GenerateAndAddPolygonCommand.CanExecute());
}
public MainWindow(PolygonManagementViewModel viewModel, IRegionManager regionManager)
{
regionManager.RegisterViewWithRegion(RegionNames.GraphicalViewer, typeof(PolygonsViewer));
regionManager.RegisterViewWithRegion(RegionNames.MainMenu, typeof(MainMenu));
regionManager.RegisterViewWithRegion(RegionNames.PolygonList, typeof(PolygonsList));
regionManager.RegisterViewWithRegion(RegionNames.PolygonDetails, typeof(PolygonDetails));
InitializeComponent();
//this.DataContext = this;
this.DataContext = viewModel;
//((PolygonManagementViewModel)this.DataContext).SelectedPolygonGenerator =
// new RandomPolygonGenerator();
}
public void CancelAreaCalculation()
{
(var tcs, var mockCalculator) = GetMockAreaCalculator();
var vm = new PolygonManagementViewModel(null, mockCalculator.Object);
vm.SelectedPolygon = new Polygon();
vm.CalculateAreaForSelectedPolygonCommand.Execute();
tcs.SetCanceled();
// Check state after cancellation
Assert.Null(vm.Area);
Assert.True(vm.CalculateAreaForSelectedPolygonCommand.CanExecute());
Assert.False(vm.CancelAreaCalculationCommand.CanExecute());
}
public void FillPolygonGeneratorsFromContainer()
{
var mockGenerator = new Mock <PolygonGeneratorProvider>();
mockGenerator.Setup(x => x.GetGenerators()).Returns(new[] { new DummyGenerator() });
var vm = new PolygonManagementViewModel(mockGenerator.Object);
Assert.Single(vm.Generators);
var generator = vm.Generators.First();
Assert.Equal("Dummy", generator.FriendlyName);
Assert.IsType <DummyGenerator>(generator.Generator);
Assert.Equal(vm.SelectedPolygonGenerator, generator.Generator);
}
public void FillPolygonGeneratorsFromContainer()
{
var mockGenerator = new Mock <IUnityContainer>();
mockGenerator.Setup(x => x.Resolve(It.IsAny <Type>(), It.IsAny <string>(), It.IsAny <ResolverOverride[]>()))
.Returns(new[] { new DummyGenerator() });
var vm = new PolygonManagementViewModel(mockGenerator.Object);
Assert.Single(vm.Generators);
var generator = vm.Generators.First();
Assert.Equal("Dummy", generator.FriendlyName);
Assert.IsType <DummyGenerator>(generator.Generator);
Assert.Equal(vm.SelectedPolygonGenerator, generator.Generator);
}
public void GeneratePolygon()
{
var vm = new PolygonManagementViewModel();
vm.SelectedPolygonGenerator = GetMockGenerator().Object;
vm.GenerateAndAddPolygonCommand.Execute();
Assert.Single(vm.Polygons);
var newPolygon = vm.Polygons[0];
Assert.True(!string.IsNullOrEmpty(newPolygon.Description));
Assert.Equal(newPolygon.StrokeColor.R, newPolygon.FillColor.R);
Assert.Equal(newPolygon.StrokeColor.G, newPolygon.FillColor.G);
Assert.Equal(newPolygon.StrokeColor.B, newPolygon.FillColor.B);
}
public void ClipPossibleWithMultiplePolygons()
{
var clipper = new DummyClipper();
var dummyGenerator = Mock.Of <IPolygonGenerator>();
using var vm = new PolygonManagementViewModel(new[] { dummyGenerator }, null, clipper);
Assert.False(vm.ClipPolygonsCommand.CanExecute());
Assert.Empty(vm.Polygons);
vm.GenerateAndAddPolygonCommand.Execute();
vm.GenerateAndAddPolygonCommand.Execute();
Assert.True(vm.ClipPolygonsCommand.CanExecute());
vm.ClipPolygonsCommand.Execute();
Assert.Equal(3, vm.Polygons.Count);
}
public void ClipReplacesExistingPolygons()
{
var mockGenerator = new Mock <PolygonGenerator>();
var mockProvider = new Mock <PolygonGeneratorProvider>();
mockProvider.Setup(x => x.GetGenerators()).Returns(new[] { mockGenerator.Object });
var mockClipper = new Mock <PolygonClipper>();
mockClipper.Setup(x => x.GetIntersectedPolygon(It.IsAny <ReadOnlyMemory <Point> >(), It.IsAny <ReadOnlyMemory <Point> >()))
.Returns(new[] { new Point(0d, 0d) });
var vm = new PolygonManagementViewModel(mockProvider.Object, null, mockClipper.Object);
vm.GenerateAndAddPolygonCommand.Execute();
vm.GenerateAndAddPolygonCommand.Execute();
vm.ClipPolygonsCommand.Execute();
Assert.Single(vm.Polygons);
}
public void GeneratePolygon()
{
var mockGenerator = GetMockGenerator();
using var vm = new PolygonManagementViewModel(Array.Empty <IPolygonGenerator>())
{
SelectedPolygonGenerator = mockGenerator.Object
};
vm.GenerateAndAddPolygonCommand.Execute();
mockGenerator.Verify(x => x.Generate(in It.Ref <double> .IsAny), Times.Once());
Assert.Single(vm.Polygons);
var newPolygon = vm.Polygons[0];
Assert.False(string.IsNullOrEmpty(newPolygon.Description));
Assert.Equal(newPolygon.StrokeColor.R, newPolygon.FillColor.R);
Assert.Equal(newPolygon.StrokeColor.G, newPolygon.FillColor.G);
Assert.Equal(newPolygon.StrokeColor.B, newPolygon.FillColor.B);
}
public MainMenu(PolygonManagementViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
}
public void CalculationNotPossibleIfNoPolygonSelected()
{
var vm = new PolygonManagementViewModel(null, new Mock <AreaCalculator>().Object);
Assert.False(vm.CalculateAreaForSelectedPolygonCommand.CanExecute());
}
public PolygonDetails(PolygonManagementViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
}
public MainWindow(PolygonManagementViewModel vm)
{
InitializeComponent();
DataContext = vm;
}
public void CalculationNotPossibleIfNoPolygonSelected()
{
using var vm = new PolygonManagementViewModel(Array.Empty <IPolygonGenerator>(), new Mock <IAreaCalculator>().Object);
Assert.False(vm.CalculateAreaForSelectedPolygonCommand.CanExecute());
}
