Added ItemFilterScriptRepository

Filtration.Tests/Filtration.Tests.csproj

@@ -50,6 +50,7 @@
     <Compile Include="Models\TestItemFilterBlockGroup.cs" />
     <Compile Include="Models\TestItemFilterScript.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Repositories\TestItemFilterScriptRepository.cs" />
     <Compile Include="Services\TestItemFilterPersistenceService.cs" />
     <Compile Include="Services\TestStaticDataService.cs" />
     <Compile Include="Translators\TestBlockGroupHierarchyBuilder.cs" />

Filtration.Tests/Repositories/TestItemFilterScriptRepository.cs

@@ -0,0 +1,123 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Filtration.Repositories;
+using Filtration.Services;
+using Filtration.ViewModels;
+using Moq;
+using NUnit.Framework;
+
+namespace Filtration.Tests.Repositories
+{
+    [TestFixture]
+    public class TestItemFilterScriptRepository
+    {
+        [Test]
+        public void LoadScriptFromFile_CallsPersistenceServiceUsingPathAndReturnsViewModel()
+        {
+            // Arrange
+            var testInputPath = "C:\\TestPath.filter";
+            
+
+            var mockPersistenceService = new Mock<IItemFilterPersistenceService>();
+            mockPersistenceService.Setup(p => p.LoadItemFilterScript(testInputPath)).Verifiable();
+            
+            var mockItemFilterScriptViewModel = new Mock<IItemFilterScriptViewModel>();
+            
+            var mockItemFilterScriptViewModelFactory = new Mock<IItemFilterScriptViewModelFactory>();
+            mockItemFilterScriptViewModelFactory.Setup(f => f.Create()).Returns(mockItemFilterScriptViewModel.Object);
+
+            var repository = new ItemFilterScriptRepository(mockPersistenceService.Object, mockItemFilterScriptViewModelFactory.Object);
+
+            // Act
+            var result = repository.LoadScriptFromFile(testInputPath);
+
+            // Assert
+            mockPersistenceService.Verify();
+            Assert.AreEqual(mockItemFilterScriptViewModel.Object, result);
+        }
+
+        [Test]
+        public void LoadScriptFromFile_PersistenceServiceThrows_ThrowsIOException()
+        {
+            // Arrange
+            var testInputPath = "C:\\TestPath.filter";
+
+            var mockPersistenceService = new Mock<IItemFilterPersistenceService>();
+            mockPersistenceService.Setup(p => p.LoadItemFilterScript(testInputPath)).Throws<IOException>();
+
+            var mockItemFilterScriptViewModelFactory = new Mock<IItemFilterScriptViewModelFactory>();
+
+            var repository = new ItemFilterScriptRepository(mockPersistenceService.Object, mockItemFilterScriptViewModelFactory.Object);
+
+            // Act
+            
+            // Assert
+            Assert.Throws<IOException>(() => repository.LoadScriptFromFile(testInputPath));
+        }
+
+        [Test]
+        public void SetItemFilterScriptDirectory_CallsPersistenceServiceSetItemFilterScriptDirectory()
+        {
+            // Arrange
+            var testInputPath = "C:\\Test\\Path";
+
+            var mockPersistenceService = new Mock<IItemFilterPersistenceService>();
+            mockPersistenceService.Setup(p => p.SetItemFilterScriptDirectory(testInputPath)).Verifiable();
+
+            var mockItemFilterScriptViewModelFactory = new Mock<IItemFilterScriptViewModelFactory>();
+
+            var repository = new ItemFilterScriptRepository(mockPersistenceService.Object, mockItemFilterScriptViewModelFactory.Object);
+
+            // Act
+            repository.SetItemFilterScriptDirectory(testInputPath);
+
+            // Assert
+            mockPersistenceService.Verify();
+        }
+
+        [Test]
+        public void GetItemFilterScriptDirectory_ReturnsItemFilterScriptDirectoryFromPersistenceService()
+        {
+            // Arrange
+            var testInputPath = "C:\\Test\\Path";
+
+            var mockPersistenceService = new Mock<IItemFilterPersistenceService>();
+            mockPersistenceService.SetupGet(p => p.ItemFilterScriptDirectory).Returns(testInputPath).Verifiable();
+
+            var mockItemFilterScriptViewModelFactory = new Mock<IItemFilterScriptViewModelFactory>();
+
+            var repository = new ItemFilterScriptRepository(mockPersistenceService.Object, mockItemFilterScriptViewModelFactory.Object);
+
+            // Act
+            string result =  repository.GetItemFilterScriptDirectory();
+
+            // Assert
+            mockPersistenceService.Verify();
+            Assert.AreEqual(result, testInputPath);
+        }
+
+        [Test]
+        public void NewScript_ReturnsScriptFromViewModelFactory()
+        {
+            // Arrange
+            var mockPersistenceService = new Mock<IItemFilterPersistenceService>();
+            
+            var mockItemFilterScriptViewModel = new Mock<IItemFilterScriptViewModel>();
+
+            var mockItemFilterScriptViewModelFactory = new Mock<IItemFilterScriptViewModelFactory>();
+            mockItemFilterScriptViewModelFactory.Setup(f => f.Create()).Returns(mockItemFilterScriptViewModel.Object);
+
+            var repository = new ItemFilterScriptRepository(mockPersistenceService.Object, mockItemFilterScriptViewModelFactory.Object);
+            
+            // Act
+            IItemFilterScriptViewModel result = repository.NewScript();
+
+            // Assert
+            Assert.AreEqual(mockItemFilterScriptViewModel.Object, result);
+        }
+    }
+}

Filtration.Tests/Services/TestItemFilterPersistenceService.cs

@@ -1,4 +1,5 @@
-using Filtration.Models;
+using System.IO;
+using Filtration.Models;
 using Filtration.Services;
 using Filtration.Translators;
 using Moq;
@@ -79,5 +80,44 @@ namespace Filtration.Tests.Services
             // Assert
             mockFileSystemService.Verify();
         }
+
+        [Test]
+        public void SetItemFilterScriptDirectory_InvalidPath_ThrowsDirectoryNotFoundException()
+        {
+            // Arrange
+            var testInputPath = "C:\\Test\\Path";
+
+            var mockFileSystemService = new Mock<IFileSystemService>();
+            mockFileSystemService.Setup(f => f.DirectoryExists(testInputPath)).Returns(false).Verifiable();
+
+            var mockItemFilterScriptTranslator = new Mock<IItemFilterScriptTranslator>();
+
+            var service = new ItemFilterPersistenceService(mockFileSystemService.Object, mockItemFilterScriptTranslator.Object);
+
+            // Act
+            
+            // Assert
+            Assert.Throws<DirectoryNotFoundException>(() => service.SetItemFilterScriptDirectory(testInputPath));
+        }
+
+        [Test]
+        public void SetItemFilterScriptDirectory_ValidPath_SetsItemFilterScriptDirectory()
+        {
+            // Arrange
+            var testInputPath = "C:\\Test\\Path";
+
+            var mockFileSystemService = new Mock<IFileSystemService>();
+            mockFileSystemService.Setup(f => f.DirectoryExists(testInputPath)).Returns(true).Verifiable();
+
+            var mockItemFilterScriptTranslator = new Mock<IItemFilterScriptTranslator>();
+
+            var service = new ItemFilterPersistenceService(mockFileSystemService.Object, mockItemFilterScriptTranslator.Object);
+
+            // Act
+            service.SetItemFilterScriptDirectory(testInputPath);
+
+            // Assert
+            Assert.AreEqual(testInputPath, service.ItemFilterScriptDirectory);
+        }
     }
 }

Filtration/Filtration.csproj

@@ -167,6 +167,7 @@
     <Compile Include="Models\BlockItemBaseTypes\SocketGroupBlockItemBase.cs" />
     <Compile Include="Models\ReplaceColorsParameterSet.cs" />
     <Compile Include="Properties\Annotations.cs" />
+    <Compile Include="Repositories\ItemFilterScriptRepository.cs" />
     <Compile Include="Services\FileSystemService.cs" />
     <Compile Include="Services\ItemFilterPersistenceService.cs" />
     <Compile Include="Services\StaticDataService.cs" />
@@ -240,6 +241,7 @@
       <DependentUpon>StartPageView.xaml</DependentUpon>
     </Compile>
     <Compile Include="WindsorInstallers\ModelsInstaller.cs" />
+    <Compile Include="WindsorInstallers\RepositoriesInstaller.cs" />
     <Compile Include="WindsorInstallers\ServicesInstaller.cs" />
     <Compile Include="WindsorInstallers\TranslatorsInstaller.cs" />
     <Compile Include="WindsorInstallers\ViewModelsInstaller.cs" />

Filtration/Repositories/ItemFilterScriptRepository.cs

@@ -0,0 +1,68 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Filtration.Models;
+using Filtration.Services;
+using Filtration.ViewModels;
+
+namespace Filtration.Repositories
+{
+    internal interface IItemFilterScriptRepository
+    {
+        IItemFilterScriptViewModel LoadScriptFromFile(string path);
+        IItemFilterScriptViewModel NewScript();
+        string GetItemFilterScriptDirectory();
+        void SetItemFilterScriptDirectory(string path);
+    }
+
+    internal class ItemFilterScriptRepository : IItemFilterScriptRepository
+    {
+        private readonly IItemFilterPersistenceService _itemFilterPersistenceService;
+        private readonly IItemFilterScriptViewModelFactory _itemFilterScriptViewModelFactory;
+        //private List<ItemFilterScript> _itemFilterScripts;
+
+        public ItemFilterScriptRepository(IItemFilterPersistenceService itemFilterPersistenceService,
+                                          IItemFilterScriptViewModelFactory itemFilterScriptViewModelFactory)
+        {
+            _itemFilterPersistenceService = itemFilterPersistenceService;
+            _itemFilterScriptViewModelFactory = itemFilterScriptViewModelFactory;
+        }
+
+        public IItemFilterScriptViewModel LoadScriptFromFile(string path)
+        {
+            ItemFilterScript loadedScript;
+            try
+            {
+                loadedScript = _itemFilterPersistenceService.LoadItemFilterScript(path);
+            }
+            catch (Exception e)
+            {
+                throw new IOException("Error loading filter script - " + e.Message);
+            }
+
+            var newViewModel = _itemFilterScriptViewModelFactory.Create();
+            newViewModel.Initialise(loadedScript, false);
+
+            return newViewModel;
+        }
+
+        public IItemFilterScriptViewModel NewScript()
+        {
+            var newScript = new ItemFilterScript();
+            var newViewModel = _itemFilterScriptViewModelFactory.Create();
+            newViewModel.Initialise(newScript, true);
+
+            return newViewModel;
+        }
+        
+        public void SetItemFilterScriptDirectory(string path)
+        {
+            _itemFilterPersistenceService.SetItemFilterScriptDirectory(path);
+        }
+
+        public string GetItemFilterScriptDirectory()
+        {
+            return _itemFilterPersistenceService.ItemFilterScriptDirectory;
+        }
+    }
+}

Filtration/Services/ItemFilterPersistenceService.cs

@@ -1,11 +1,13 @@
-using Filtration.Models;
+using System.IO;
+using Filtration.Models;
 using Filtration.Translators;
 
 namespace Filtration.Services
 {
     internal interface IItemFilterPersistenceService
     {
-        string ItemFilterScriptDirectory { get; set; }
+        void SetItemFilterScriptDirectory(string path);
+        string ItemFilterScriptDirectory { get; }
         ItemFilterScript LoadItemFilterScript(string filePath);
         void SaveItemFilterScript(ItemFilterScript script);
         string DefaultPathOfExileDirectory();
@@ -20,9 +22,30 @@ namespace Filtration.Services
         {
             _fileSystemService = fileSystemService;
             _itemFilterScriptTranslator = itemFilterScriptTranslator;
+
+            ItemFilterScriptDirectory = DefaultPathOfExileDirectory();
         }
 
-        public string ItemFilterScriptDirectory { get; set; }
+        public string ItemFilterScriptDirectory { get; private set; }
+
+        public string DefaultPathOfExileDirectory()
+        {
+            var defaultDir = _fileSystemService.GetUserProfilePath() + "\\Documents\\My Games\\Path of Exile";
+            var defaultDirExists = _fileSystemService.DirectoryExists(defaultDir);
+
+            return defaultDirExists ? defaultDir : string.Empty;
+        }
+
+        public void SetItemFilterScriptDirectory(string path)
+        {
+            var validPath = _fileSystemService.DirectoryExists(path);
+            if (!validPath)
+            {
+                throw new DirectoryNotFoundException();
+            }
+
+            ItemFilterScriptDirectory = path;
+        }
 
         public ItemFilterScript LoadItemFilterScript(string filePath)
         {
@@ -40,12 +63,6 @@ namespace Filtration.Services
                 _itemFilterScriptTranslator.TranslateItemFilterScriptToString(script));
         }
 
-        public string DefaultPathOfExileDirectory()
-        {
-            var defaultDir = _fileSystemService.GetUserProfilePath() + "\\Documents\\My Games\\Path of Exile";
-            var defaultDirExists = _fileSystemService.DirectoryExists(defaultDir);
 
-            return defaultDirExists ? defaultDir : string.Empty;
-        }
     }
 }

Filtration/ViewModels/MainWindowViewModel.cs

@@ -1,8 +1,10 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Reflection;
 using System.Windows.Forms;
 using Filtration.Models;
+using Filtration.Repositories;
 using Filtration.Services;
 using Filtration.Translators;
 using Filtration.Views;
@@ -16,29 +18,25 @@ namespace Filtration.ViewModels
 {
     internal interface IMainWindowViewModel
     {
-        void LoadScriptFromFile(string path);
         RelayCommand OpenScriptCommand { get; }
         RelayCommand NewScriptCommand { get; }
     }
 
     internal class MainWindowViewModel : FiltrationViewModelBase, IMainWindowViewModel
     {
-        private readonly IItemFilterScriptViewModelFactory _itemFilterScriptViewModelFactory;
+        private readonly IItemFilterScriptRepository _itemFilterScriptRepository;
-        private readonly IItemFilterPersistenceService _persistenceService;
         private readonly IItemFilterScriptTranslator _itemFilterScriptTranslator;
         private readonly IReplaceColorsViewModel _replaceColorsViewModel;
         private readonly IAvalonDockWorkspaceViewModel _avalonDockWorkspaceViewModel;
 
         private IDocument _activeDocument;
 
-        public MainWindowViewModel(IItemFilterScriptViewModelFactory itemFilterScriptViewModelFactory,
+        public MainWindowViewModel(IItemFilterScriptRepository itemFilterScriptRepository,
-                                   IItemFilterPersistenceService persistenceService,
                                    IItemFilterScriptTranslator itemFilterScriptTranslator,
                                    IReplaceColorsViewModel replaceColorsViewModel,
                                    IAvalonDockWorkspaceViewModel avalonDockWorkspaceViewModel)
         {
-            _itemFilterScriptViewModelFactory = itemFilterScriptViewModelFactory;
+            _itemFilterScriptRepository = itemFilterScriptRepository;
-            _persistenceService = persistenceService;
             _itemFilterScriptTranslator = itemFilterScriptTranslator;
             _replaceColorsViewModel = replaceColorsViewModel;
             _avalonDockWorkspaceViewModel = avalonDockWorkspaceViewModel;
@@ -56,7 +54,10 @@ namespace Filtration.ViewModels
 
             //LoadScriptFromFile("C:\\ThioleLootFilter.txt");
 
-            SetItemFilterScriptDirectory();
+            if (string.IsNullOrEmpty(_itemFilterScriptRepository.GetItemFilterScriptDirectory()))
+            {
+                SetItemFilterScriptDirectory();
+            }
 
             Messenger.Default.Register<NotificationMessage>(this, message =>
             {
@@ -131,53 +132,40 @@ namespace Filtration.ViewModels
             var openFileDialog = new OpenFileDialog
             {
                 Filter = "Filter Files (*.filter)|*.filter|All Files (*.*)|*.*",
-                InitialDirectory = _persistenceService.ItemFilterScriptDirectory
+                InitialDirectory = _itemFilterScriptRepository.GetItemFilterScriptDirectory()
             };
 
             if (openFileDialog.ShowDialog() != true) return;
 
-            LoadScriptFromFile(openFileDialog.FileName);
+            IItemFilterScriptViewModel loadedViewModel;
-        }
 
-        public void LoadScriptFromFile(string path)
-        {
-            var loadedScript = _persistenceService.LoadItemFilterScript(path);
             try
             {
-                
+                loadedViewModel = _itemFilterScriptRepository.LoadScriptFromFile(openFileDialog.FileName);
             }
-            catch (Exception e)
+            catch(IOException e)
             {
-                MessageBox.Show(@"Error loading filter script - " + e.Message, @"Script Load Error", MessageBoxButtons.OK,
+                MessageBox.Show(@"Error loading filter script - " + e.Message, @"Script Load Error",
-                   MessageBoxIcon.Error);
+                    MessageBoxButtons.OK,
+                    MessageBoxIcon.Error);
                 return;
             }
 
-            var newViewModel = _itemFilterScriptViewModelFactory.Create();
+            _avalonDockWorkspaceViewModel.AddDocument(loadedViewModel);
-            newViewModel.Initialise(loadedScript, false);
-            _avalonDockWorkspaceViewModel.AddDocument(newViewModel);
         }
 
         private void SetItemFilterScriptDirectory()
         {
-            var defaultDir = _persistenceService.DefaultPathOfExileDirectory();
+            var dlg = new FolderBrowserDialog
-            if (!string.IsNullOrEmpty(defaultDir))
             {
-                _persistenceService.ItemFilterScriptDirectory = defaultDir;
+                Description = @"Select your Path of Exile data directory, usually in Documents\My Games",
-            }
+                ShowNewFolderButton = false
-            else
+            };
-            {
+            var result = dlg.ShowDialog();
-                var dlg = new FolderBrowserDialog
-                {
-                    Description = @"Select your Path of Exile data directory, usually in Documents\My Games",
-                    ShowNewFolderButton = false
-                };
-                var result = dlg.ShowDialog();
 
-                if (result == DialogResult.OK)
+            if (result == DialogResult.OK)
-                {
+            {
-                    _persistenceService.ItemFilterScriptDirectory = dlg.SelectedPath;
+                _itemFilterScriptRepository.SetItemFilterScriptDirectory(dlg.SelectedPath);
-                }
             }
         }
 
@@ -215,9 +203,7 @@ namespace Filtration.ViewModels
 
         private void OnNewScriptCommand()
         {
-            var newScript = new ItemFilterScript();
+            var newViewModel = _itemFilterScriptRepository.NewScript();
-            var newViewModel = _itemFilterScriptViewModelFactory.Create();
-            newViewModel.Initialise(newScript, true);
             _avalonDockWorkspaceViewModel.AddDocument(newViewModel);
         }
 

Filtration/Views/MainWindow.xaml.cs

@@ -5,23 +5,14 @@ namespace Filtration.Views
     public interface IMainWindow
     {
         void Show();
-        void OpenScriptFromCommandLineArgument(string scriptPath);
     }
 
     internal partial class MainWindow : IMainWindow
     {
-        private readonly IMainWindowViewModel _mainWindowViewModel;
-
         public MainWindow(IMainWindowViewModel mainWindowViewModel)
         {
-            _mainWindowViewModel = mainWindowViewModel;
             InitializeComponent();
             DataContext = mainWindowViewModel;
         }
-
-        public void OpenScriptFromCommandLineArgument(string scriptPath)
-        {
-            _mainWindowViewModel.LoadScriptFromFile(scriptPath);
-        }
     }
 }

Filtration/WindsorInstallers/RepositoriesInstaller.cs

@@ -0,0 +1,18 @@
+using Castle.MicroKernel.Registration;
+using Castle.MicroKernel.SubSystems.Configuration;
+using Castle.Windsor;
+using Filtration.Repositories;
+
+namespace Filtration.WindsorInstallers
+{
+    public class RepositoriesInstaller :IWindsorInstaller
+    {
+        public void Install(IWindsorContainer container, IConfigurationStore store)
+        {
+            container.Register(
+                Component.For<IItemFilterScriptRepository>()
+                    .ImplementedBy<ItemFilterScriptRepository>()
+                    .LifeStyle.Singleton);
+        }
+    }
+}