Adding a bunch of tests to see if Interface is complete

OctoPatch.sln

@@ -31,6 +31,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OctoPatch.Plugin.Keyboard",
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OctoPatch.Plugin.Rest", "src\Plugins\OctoPatch.Plugin.Rest\OctoPatch.Plugin.Rest.csproj", "{35E27930-07AA-4AE2-999E-E6BBE4B71DFB}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OctoPatch.Server.Test", "test\OctoPatch.Server.Test\OctoPatch.Server.Test.csproj", "{91546803-665C-4CC1-B849-8498947F5186}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -81,6 +83,10 @@ Global
 		{35E27930-07AA-4AE2-999E-E6BBE4B71DFB}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{35E27930-07AA-4AE2-999E-E6BBE4B71DFB}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{35E27930-07AA-4AE2-999E-E6BBE4B71DFB}.Release|Any CPU.Build.0 = Release|Any CPU
+		{91546803-665C-4CC1-B849-8498947F5186}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{91546803-665C-4CC1-B849-8498947F5186}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{91546803-665C-4CC1-B849-8498947F5186}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{91546803-665C-4CC1-B849-8498947F5186}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -93,6 +99,7 @@ Global
 		{DBA37B79-AF44-4C21-8BD6-B7704BD339F5} = {FA7B21A1-3ADA-4C35-BF59-100BFD2A689D}
 		{DD956A0D-1556-4CCA-B1F3-4010D0F0F8F3} = {826BC5FD-CEF2-466A-88E5-55489BDAD44B}
 		{35E27930-07AA-4AE2-999E-E6BBE4B71DFB} = {826BC5FD-CEF2-466A-88E5-55489BDAD44B}
+		{91546803-665C-4CC1-B849-8498947F5186} = {FA7B21A1-3ADA-4C35-BF59-100BFD2A689D}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {8F9B99B3-F5BE-4428-9751-1CC99FA5761B}

src/Applications/OctoPatch.DesktopClient/ConfigurationMap.cs

@@ -0,0 +1,115 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using OctoPatch.DesktopClient.Models;
+using System.Reflection;
+using System.Windows;
+using System.Windows.Controls;
+
+namespace OctoPatch.DesktopClient
+{
+    /// <summary>
+    /// Central place to map configuration setup (node/adapter key to configuration model and configuration view)
+    /// </summary>
+    public sealed class ConfigurationMap
+    {
+        /// <summary>
+        /// Holds the current map
+        /// </summary>
+        private static readonly List<MapEntry> Map = new List<MapEntry>();
+
+        /// <summary>
+        /// Constructor scans for existing configuration map attributes within the current app domain
+        /// </summary>
+        static ConfigurationMap()
+        {
+            // Scan all referenced assemblies
+            foreach (var assemblies in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                try
+                {
+                    // Scan all types
+                    foreach (var type in assemblies.GetTypes())
+                    {
+                        // Scan all existing attributes
+                        foreach (var attribute in type.GetCustomAttributes<ConfigurationMapAttribute>())
+                        {
+                            Map.Add(new MapEntry(attribute.Key, attribute.ModelType, type));
+                        }
+                    }
+                }
+                catch (Exception)
+                {
+                    // Some assemblies are not allowed to be reflected...?
+                }
+            }
+        }
+
+        /// <summary>
+        /// Returns a new instance of the configuration model fitting to the given key or null, when no key is registered
+        /// </summary>
+        /// <param name="key">node key</param>
+        /// <returns>new model instance</returns>
+        public static ConfigurationModel GetConfigurationModel(string key)
+        {
+            var entry = Map.FirstOrDefault(e => string.Equals(e.Key, key, StringComparison.InvariantCultureIgnoreCase));
+            return entry == null ? null : (ConfigurationModel)Activator.CreateInstance(entry.ModelType);
+        }
+
+        public static UserControl GetConfigurationView(ConfigurationModel model)
+        {
+            if (model == null)
+            {
+                return null;
+            }
+
+            var entry = Map.FirstOrDefault(e => e.ModelType == model.GetType());
+            if (entry == null)
+            {
+                return null;
+            }
+
+            var control = (UserControl) Activator.CreateInstance(entry.ViewType);
+
+            // Set data context if possible
+            if (control != null)
+            {
+                control.DataContext = model;
+            }
+
+            return control;
+        }
+
+        #region nested types
+
+        /// <summary>
+        /// Local container to store a map entry
+        /// </summary>
+        private class MapEntry
+        {
+            /// <summary>
+            /// Gets the type of the data model
+            /// </summary>
+            public Type ModelType { get; }
+
+            /// <summary>
+            /// Gets the type of the view
+            /// </summary>
+            public Type ViewType { get; }
+
+            /// <summary>
+            /// Gets the key of the node or adapter
+            /// </summary>
+            public string Key { get; }
+
+            public MapEntry(string key, Type modelType, Type viewType)
+            {
+                Key = key;
+                ModelType = modelType;
+                ViewType = viewType;
+            }
+        }
+
+        #endregion
+    }
+}

src/Applications/OctoPatch.DesktopClient/ConfigurationMapAttribute.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace OctoPatch.DesktopClient
+{
+    /// <summary>
+    /// Attribute to decorate the configuration view with
+    /// </summary>
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
+    public sealed class ConfigurationMapAttribute : Attribute
+    {
+        /// <summary>
+        /// Gets the key string for the node or adapter
+        /// </summary>
+        public string Key { get; }
+
+        /// <summary>
+        /// Gets the model type which handles the node or adapter settings
+        /// </summary>
+        public Type ModelType { get; }
+
+        public ConfigurationMapAttribute(string key, Type modelType)
+        {
+            Key = key;
+            ModelType = modelType;
+        }
+    }
+}

src/Applications/OctoPatch.DesktopClient/Converters/InRangeToVisibilityConverter.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Globalization;
+using System.Windows;
+using System.Windows.Data;
+
+namespace OctoPatch.DesktopClient.Converters
+{
+    /// <summary>
+    /// Checks if the given value is within the range
+    /// </summary>
+    [ValueConversion(typeof(int), typeof(Visibility))]
+    public sealed class InRangeToVisibilityConverter : IValueConverter
+    {
+        /// <summary>
+        /// Minimum value
+        /// </summary>
+        public int MinValue { get; set; }
+
+        /// <summary>
+        /// Maximum value
+        /// </summary>
+        public int MaxValue { get; set; }
+
+        public InRangeToVisibilityConverter()
+        {
+            MinValue = int.MinValue;
+            MaxValue = int.MaxValue;
+        }
+
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (!(value is int input))
+            {
+                return Visibility.Collapsed;
+            }
+
+            return input >= MinValue && input <= MaxValue ? Visibility.Visible : Visibility.Collapsed;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

src/Applications/OctoPatch.DesktopClient/Converters/NodeToVisibilityConverter.cs

@@ -6,12 +6,87 @@
 
 namespace OctoPatch.DesktopClient.Converters
 {
+    /// <summary>
+    /// Converts selected tree node type into visibility
+    /// </summary>
     [ValueConversion(typeof(NodeModel), typeof(Visibility))]
     class NodeToVisibilityConverter : IValueConverter
     {
+        /// <summary>
+        /// show up when common node is selected
+        /// </summary>
+        public bool CommonNode { get; set; }
+
+        /// <summary>
+        /// show up when attached node is selected
+        /// </summary>
+        public bool AttachedNode { get; set; }
+
+        /// <summary>
+        /// show up when splitter node is selected
+        /// </summary>
+        public bool SplitterNode { get; set; }
+
+        /// <summary>
+        /// show up when collector node is selected
+        /// </summary>
+        public bool CollectorNode { get; set; }
+
+        /// <summary>
+        /// show up when input connector is selected
+        /// </summary>
+        public bool InputConnector { get; set; }
+
+        /// <summary>
+        /// show up when output connector is selected
+        /// </summary>
+        public bool OutputConnector { get; set; }
+
+        /// <summary>
+        /// show up when wire is selected
+        /// </summary>
+        public bool Wire { get; set; }
+
         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            return value is CommonNodeModel || value is AttachedNodeModel || value is SplitterNodeModel || value is CollectorNodeModel ? Visibility.Visible : Visibility.Collapsed;
+            var visible = false;
+
+            if (CommonNode && value is CommonNodeModel)
+            {
+                visible = true;
+            }
+
+            if (AttachedNode && value is AttachedNodeModel)
+            {
+                visible = true;
+            }
+
+            if (SplitterNode && value is SplitterNodeModel)
+            {
+                visible = true;
+            }
+
+            if (CollectorNode && value is CollectorNodeModel)
+            {
+                visible = true;
+            }
+
+            if (InputConnector && value is InputNodeModel)
+            {
+                visible = true;
+            }
+
+            if (OutputConnector && value is OutputNodeModel)
+            {
+                visible = true;
+            }
+
+            if (Wire && value is WireNodeModel)
+            {
+                visible = true;
+            }
+
+            return visible ? Visibility.Visible : Visibility.Collapsed;
         }
 
         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)

src/Applications/OctoPatch.DesktopClient/MainWindow.xaml

@@ -6,7 +6,5 @@
         xmlns:views="clr-namespace:OctoPatch.DesktopClient.Views"
         mc:Ignorable="d"
         Title="OctoPatch Desktop" Height="700" Width="800">
-    <Grid>
-        <views:RuntimeView HorizontalAlignment="Stretch" VerticalAlignment="Stretch" />
-    </Grid>
+    <views:RuntimeView HorizontalAlignment="Stretch" VerticalAlignment="Stretch" />
 </Window>

src/Applications/OctoPatch.DesktopClient/Models/AdapterConfigurationModel.cs

@@ -0,0 +1,38 @@
+using Newtonsoft.Json;
+
+namespace OctoPatch.DesktopClient.Models
+{
+    /// <summary>
+    /// Basic configuration type for node configuration
+    /// </summary>
+    /// <typeparam name="TConfiguration">model type for configuration</typeparam>
+    /// <typeparam name="TEnvironment">model type for environment</typeparam>
+    public abstract class AdapterConfigurationModel<TConfiguration, TEnvironment> : ConfigurationModel
+        where TConfiguration : IConfiguration
+        where TEnvironment : IEnvironment
+    {
+        public override void Setup(string environment)
+        {
+            // Do nothing since adapter do not have any environment yet
+        }
+
+        public override void SetConfiguration(string configuration)
+        {
+            if (configuration == null)
+            {
+                return;
+            }
+
+            OnSetConfiguration(JsonConvert.DeserializeObject<TConfiguration>(configuration));
+        }
+
+        protected abstract void OnSetConfiguration(TConfiguration configuration);
+
+        public override string GetConfiguration()
+        {
+            return JsonConvert.SerializeObject(OnGetConfiguration());
+        }
+
+        protected abstract TConfiguration OnGetConfiguration();
+    }
+}