From fdcf18ef0c76787227c6e4fbda7fd05e4429e4db Mon Sep 17 00:00:00 2001
From: John Gathogo <john.gathogo@gmail.com>
Date: Tue, 19 Jan 2021 11:08:28 +0300
Subject: [PATCH] Set the most logical config defaults for the wizard (#187)

* Set the most logical config defaults plus cleanup refactor

* Fix unnecessary use of this

* Revert version bump

Co-authored-by: John Gathogo <jogathogo@microsoft.com>
---
 src/Common/ExtensionMethods.cs                |  46 ++
 src/Common/UserSettingsPersistenceHelper.cs   |   5 +-
 src/Models/ServiceConfiguration.cs            |   6 +-
 src/Models/UserSettings.cs                    | 419 +++++++++++++++---
 src/ODataConnectedService.csproj              |   1 +
 src/ODataConnectedServiceWizard.cs            | 193 ++++----
 src/Properties/AssemblyInfo.cs                |   4 +-
 src/ViewModels/AdvancedSettingsViewModel.cs   |  59 +--
 .../ConfigODataEndpointViewModel.cs           |  98 +---
 src/ViewModels/OperationImportsViewModel.cs   |   2 +-
 src/Views/AdvancedSettings.xaml               |  20 +-
 src/Views/ConfigODataEndpoint.xaml            |  20 +-
 src/Views/ConfigODataEndpoint.xaml.cs         | 147 +++---
 src/source.extension.vsixmanifest             |   2 +-
 .../Common/ExtensionMethodsTests.cs           | 149 +++++++
 .../ODataConnectedService.Tests.csproj        |   1 +
 .../ODataConnectedServiceWizardTests.cs       | 230 +++++-----
 .../ConfigOdataEndPointViewModelTests.cs      |  10 +-
 .../Views/UserSettingsTest.cs                 |  97 ++--
 19 files changed, 932 insertions(+), 577 deletions(-)
 create mode 100644 src/Common/ExtensionMethods.cs
 create mode 100644 test/ODataConnectedService.Tests/Common/ExtensionMethodsTests.cs

diff --git a/src/Common/ExtensionMethods.cs b/src/Common/ExtensionMethods.cs
new file mode 100644
index 00000000..9035de00
--- /dev/null
+++ b/src/Common/ExtensionMethods.cs
@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------------
+// <copyright file="ExtensionMethods.cs" company=".NET Foundation">
+//      Copyright (c) .NET Foundation and Contributors. All rights reserved.
+//      See License.txt in the project root for license information.
+// </copyright>
+//----------------------------------------------------------------------------
+
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace Microsoft.OData.ConnectedService.Common
+{
+    internal static class ExtensionMethods
+    {
+        /// <summary>
+        /// Copies public properties with matching name and type from one object to the other.
+        /// </summary>
+        /// <param name="target">The target.</param>
+        /// <param name="source">The source.</param>
+        public static void CopyPropertiesFrom(this object target, object source)
+        {
+            if (source == null)
+            {
+                return;
+            }
+
+            var fromProperties = source.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                .Where(d => d.GetGetMethod() != null);
+            var toProperties = target.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)
+                .Where(d => d.GetSetMethod() != null);
+
+            foreach(var toProperty in toProperties)
+            {
+                var fromProperty = fromProperties.SingleOrDefault(d => 
+                    d.Name.Equals(toProperty.Name, StringComparison.Ordinal) 
+                    && toProperty.PropertyType.IsAssignableFrom(d.PropertyType));
+
+                if (fromProperty != null)
+                {
+                    toProperty.SetValue(target, fromProperty.GetValue(source));
+                }
+            }
+        }
+    }
+}
diff --git a/src/Common/UserSettingsPersistenceHelper.cs b/src/Common/UserSettingsPersistenceHelper.cs
index 2ea64178..d9db84f9 100644
--- a/src/Common/UserSettingsPersistenceHelper.cs
+++ b/src/Common/UserSettingsPersistenceHelper.cs
@@ -36,7 +36,8 @@ public static void Save(object userSettings, string providerId, string name, Act
                         {
                             // note: this overwrites existing settings file if it exists
                             stream = file.OpenFile(fileName, FileMode.Create);
-                            using (var writer = XmlWriter.Create(stream))
+
+                            using (var writer = XmlWriter.Create(stream, new XmlWriterSettings { Indent = true }))
                             {
                                 var dcs = new DataContractSerializer(userSettings.GetType());
                                 dcs.WriteObject(writer, userSettings);
@@ -112,7 +113,7 @@ public static T Load<T>(string providerId, string name, Action<T> onLoaded, Conn
 
         private static string GetStorageFileName(string providerId, string name)
         {
-            return providerId + "_" + name + ".xml";
+            return providerId + "." + name + ".xml";
         }
 
         private static IsolatedStorageFile GetIsolatedStorageFile()
diff --git a/src/Models/ServiceConfiguration.cs b/src/Models/ServiceConfiguration.cs
index 8b2658c5..cb0f349b 100644
--- a/src/Models/ServiceConfiguration.cs
+++ b/src/Models/ServiceConfiguration.cs
@@ -39,7 +39,7 @@ internal class ServiceConfigurationV4 : ServiceConfiguration
         public bool EnableNamingAlias { get; set; }
         public bool IgnoreUnexpectedElementsAndAttributes { get; set; }
         public bool IncludeT4File { get; set; }
-        public List<string> ExcludedOperationImports;
-        public List<string> ExcludedBoundOperations;
+        public List<string> ExcludedOperationImports { get; set; }
+        public List<string> ExcludedBoundOperations { get; set; }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Models/UserSettings.cs b/src/Models/UserSettings.cs
index bd76f915..250cce94 100644
--- a/src/Models/UserSettings.cs
+++ b/src/Models/UserSettings.cs
@@ -5,147 +5,466 @@
 // </copyright>
 //----------------------------------------------------------------------------
 
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using Microsoft.OData.ConnectedService.Common;
 using Microsoft.VisualStudio.ConnectedServices;
+using Newtonsoft.Json;
 
 namespace Microsoft.OData.ConnectedService.Models
 {
     [DataContract]
-    internal class UserSettings
+    internal class UserSettings : INotifyPropertyChanged
     {
-        private const string Name = "Settings";
+        #region Const Members
+
         private const int MaxMruEntries = 10;
 
-        private ConnectedServiceLogger logger;
+        #endregion Const Members
 
-        [DataMember]
-        public ObservableCollection<string> MruEndpoints { get; set; }
+        #region Readonly Members
 
-        [DataMember]
-        public string ServiceName { get; set; }
+        private readonly ConnectedServiceLogger logger;
 
-        [DataMember]
-        public string Endpoint { get; set; }
+        private readonly string configName;
+
+        #endregion Readonly Members
+
+        #region Private Members
+
+        private ObservableCollection<string> mruEndpoints;
+
+        private string serviceName;
+
+        private string endpoint;
+
+        private string generatedFileNamePrefix;
+
+        private bool useNamespacePrefix;
+
+        private string namespacePrefix;
+
+        private bool useDataServiceCollection;
+
+        private bool makeTypesInternal;
+
+        private bool openGeneratedFilesInIDE;
+
+        private bool generateMultipleFiles;
+
+        private string customHttpHeaders;
+
+        private bool enableNamingAlias;
+
+        private bool ignoreUnexpectedElementsAndAttributes;
+
+        private bool includeT4File;
+
+        private bool includeWebProxy;
+
+        private string webProxyHost;
+
+        private bool includeWebProxyNetworkCredentials;
+
+        private string webProxyNetworkCredentialsUsername;
+
+        private string webProxyNetworkCredentialsPassword;
+
+        private string webProxyNetworkCredentialsDomain;
+
+        private bool includeCustomHeaders;
+
+        private List<string> excludedOperationImports;
+
+        private List<string> excludedBoundOperations;
+
+        private List<string> excludedSchemaTypes;
+
+        #endregion Private Members
+
+        public event PropertyChangedEventHandler PropertyChanged;
 
         [DataMember]
-        public string GeneratedFileNamePrefix { get; set; }
+        public ObservableCollection<string> MruEndpoints
+        {
+            get { return mruEndpoints; }
+            set
+            {
+                mruEndpoints = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool UseNamespacePrefix { get; set; }
+        public string ServiceName
+        {
+            get { return serviceName; }
+            set
+            {
+                serviceName = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public string NamespacePrefix { get; set; }
+        public string Endpoint
+        {
+            get { return endpoint; }
+            set
+            {
+                endpoint = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool UseDataServiceCollection { get; set; }
+        public string GeneratedFileNamePrefix
+        {
+            get { return generatedFileNamePrefix; }
+            set
+            {
+                generatedFileNamePrefix = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool MakeTypesInternal { get; set; }
+        public bool UseNamespacePrefix
+        {
+            get { return useNamespacePrefix; }
+            set
+            {
+                useNamespacePrefix = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool OpenGeneratedFilesInIDE { get; set; }
+        public string NamespacePrefix
+        {
+            get { return namespacePrefix; }
+            set
+            {
+                namespacePrefix = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool GenerateMultipleFiles { get; set; }
+        public bool UseDataServiceCollection
+        {
+            get { return useDataServiceCollection; }
+            set
+            {
+                useDataServiceCollection = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public string CustomHttpHeaders { get; set; }
+        public bool MakeTypesInternal
+        {
+            get { return makeTypesInternal; }
+            set
+            {
+                makeTypesInternal = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool EnableNamingAlias { get; set; }
+        public bool OpenGeneratedFilesInIDE
+        {
+            get { return openGeneratedFilesInIDE; }
+            set
+            {
+                openGeneratedFilesInIDE = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool IgnoreUnexpectedElementsAndAttributes { get; set; }
+        public bool GenerateMultipleFiles
+        {
+            get { return generateMultipleFiles; }
+            set
+            {
+                generateMultipleFiles = value;
+                OnPropertyChanged();
+            }
+        }
+
+        [IgnoreDataMember] // Do not serialize - may contain authentication tokens
+        public string CustomHttpHeaders
+        {
+            get { return customHttpHeaders; }
+            set
+            {
+                customHttpHeaders = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool IncludeT4File { get; set; }
+        public bool EnableNamingAlias
+        {
+            get { return enableNamingAlias; }
+            set
+            {
+                enableNamingAlias = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool IncludeWebProxy { get; set; }
+        public bool IgnoreUnexpectedElementsAndAttributes
+        {
+            get { return ignoreUnexpectedElementsAndAttributes; }
+            set
+            {
+                ignoreUnexpectedElementsAndAttributes = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public string WebProxyHost { get; set; }
+        public bool IncludeT4File
+        {
+            get { return includeT4File; }
+            set
+            {
+                includeT4File = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool IncludeWebProxyNetworkCredentials { get; set; }
+        public bool IncludeWebProxy
+        {
+            get { return includeWebProxy; }
+            set
+            {
+                includeWebProxy = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public string WebProxyNetworkCredentialsUsername { get; set; }
+        public string WebProxyHost
+        {
+            get { return webProxyHost; }
+            set
+            {
+                webProxyHost = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public string WebProxyNetworkCredentialsPassword { get; set; }
+        public bool IncludeWebProxyNetworkCredentials
+        {
+            get { return includeWebProxyNetworkCredentials; }
+            set
+            {
+                includeWebProxyNetworkCredentials = value;
+                OnPropertyChanged();
+            }
+        }
+
+        [IgnoreDataMember] // Do not serialize - security consideration
+        public string WebProxyNetworkCredentialsUsername
+        {
+            get { return webProxyNetworkCredentialsUsername; }
+            set
+            {
+                webProxyNetworkCredentialsUsername = value;
+                OnPropertyChanged();
+            }
+        }
+
+        [IgnoreDataMember] // Do not serialize - security consideration
+        public string WebProxyNetworkCredentialsPassword
+        {
+            get { return webProxyNetworkCredentialsPassword; }
+            set
+            {
+                webProxyNetworkCredentialsPassword = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public string WebProxyNetworkCredentialsDomain { get; set; }
+        public string WebProxyNetworkCredentialsDomain
+        {
+            get { return webProxyNetworkCredentialsDomain; }
+            set
+            {
+                webProxyNetworkCredentialsDomain = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public bool IncludeCustomHeaders { get; set; }
+        public bool IncludeCustomHeaders
+        {
+            get { return includeCustomHeaders; }
+            set
+            {
+                includeCustomHeaders = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public List<string> ExcludedOperationImports { get; set; }
+        public List<string> ExcludedOperationImports
+        {
+            get { return excludedOperationImports; }
+            set
+            {
+                excludedOperationImports = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public List<string> ExcludedBoundOperations { get; set; }
+        public List<string> ExcludedBoundOperations
+        {
+            get { return excludedBoundOperations; }
+            set
+            {
+                excludedBoundOperations = value;
+                OnPropertyChanged();
+            }
+        }
 
         [DataMember]
-        public List<string> ExcludedSchemaTypes { get; set; }
+        public List<string> ExcludedSchemaTypes
+        {
+            get { return excludedSchemaTypes; }
+            set
+            {
+                excludedSchemaTypes = value;
+                OnPropertyChanged();
+            }
+        }
 
-        public UserSettings()
+        protected void OnPropertyChanged([CallerMemberName] string propertyName = null)
         {
-            this.MruEndpoints = new ObservableCollection<string>();
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UserSettings"/> class.
+        /// </summary>
+        /// <param name="logger">The logger to use.</param>
+        /// <param name="configName">The name to use for the config file.</param>
+        public UserSettings(ConnectedServiceLogger logger, string configName = "Settings")
+        {
+            this.configName = configName;
+            this.logger = logger;
+            // Desired defaults
+            GeneratedFileNamePrefix = Constants.DefaultReferenceFileName;
+            NamespacePrefix = Constants.DefaultReferenceFileName;
+            ServiceName = Constants.DefaultServiceName;
+            UseDataServiceCollection = true; // To support entity and property tracking
+            EnableNamingAlias = true; // To force upper camel case in the event that entities are named in lower camel case
+            IgnoreUnexpectedElementsAndAttributes = true; // Ignore unexpected elements and attributes in the metadata document
+            ExcludedBoundOperations = new List<string>();
+            ExcludedOperationImports = new List<string>();
+            ExcludedSchemaTypes = new List<string>();
+            MruEndpoints = new ObservableCollection<string>();
+            UserSettingsPersistenceHelper.Load<UserSettings>(
+                providerId: Constants.ProviderId,
+                name: configName,
+                onLoaded: (userSettings) =>
+                {
+                    // onLoaded action is currently triggered only if settings are loaded from config file
+                    // Do this defensively all the same...
+                    if (userSettings != null)
+                    {
+                        foreach (var mruEndpoint in userSettings.MruEndpoints)
+                        {
+                            MruEndpoints.Add(mruEndpoint);
+                        }
+                    }
+                },
+                logger: logger);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UserSettings"/> class.
+        /// </summary>
+        /// <param name="configName">The name to use for the config file.</param>
+        [JsonConstructor] // Constructor should be used to create a class during deserialization
+        public UserSettings(string configName = "Settings")
+            : this(null, configName)
+        {
+        }
+
+        /// <summary>
+        /// Saves user settings to config file.
+        /// </summary>
         public void Save()
         {
-            UserSettingsPersistenceHelper.Save(this, Constants.ProviderId, UserSettings.Name, null, this.logger);
+            UserSettingsPersistenceHelper.Save(this, Constants.ProviderId, configName, null, logger);
         }
 
-        public static UserSettings Load(ConnectedServiceLogger logger)
+        /// <summary>
+        /// Loads user settings from config file.
+        /// </summary>
+        public void Load()
         {
             var userSettings = UserSettingsPersistenceHelper.Load<UserSettings>(
-                Constants.ProviderId, UserSettings.Name, null, logger) ?? new UserSettings();
-            userSettings.logger = logger;
+                Constants.ProviderId, configName, null, logger);
 
-            return userSettings;
+            if (userSettings != null)
+            {
+                this.CopyPropertiesFrom(userSettings);
+            }
         }
 
-        public static void AddToTopOfMruList<T>(ObservableCollection<T> mruList, T item)
+        /// <summary>
+        /// Adds endpoint to the most recently used endpoints collection.
+        /// </summary>
+        /// <param name="endpoint">Endpoint</param>
+        public void AddMruEndpoint(string mruEndpoint)
         {
-            if (mruList == null)
+            if (string.IsNullOrWhiteSpace(mruEndpoint))
             {
                 return;
             }
 
-            var index = mruList.IndexOf(item);
+            var index = MruEndpoints.IndexOf(mruEndpoint);
+
             if (index >= 0)
             {
-                // Ensure there aren't any duplicates in the list.
-                for (var i = mruList.Count - 1; i > index; i--)
+                // Remove possible duplicates
+                for (var i = MruEndpoints.Count - 1; index > 0 && i > index; i--)
                 {
-                    if (EqualityComparer<T>.Default.Equals(mruList[i], item))
+                    if (MruEndpoints[i].Equals(mruEndpoint, StringComparison.Ordinal))
                     {
-                        mruList.RemoveAt(i);
+                        MruEndpoints.RemoveAt(i);
                     }
                 }
 
+                // Endpoint not at index 0
                 if (index > 0)
                 {
-                    // The item is in the MRU list but it is not at the top.
-                    mruList.Move(index, 0);
+                    MruEndpoints.Move(index, 0);
                 }
             }
             else
             {
-                // The item is not in the MRU list, make room for it by clearing out the oldest item.
-                while (mruList.Count >= UserSettings.MaxMruEntries)
+                while (MruEndpoints.Count >= MaxMruEntries)
                 {
-                    mruList.RemoveAt(mruList.Count - 1);
+                    MruEndpoints.RemoveAt(MruEndpoints.Count - 1);
                 }
 
-                mruList.Insert(0, item);
+                MruEndpoints.Insert(0, mruEndpoint);
             }
         }
     }
diff --git a/src/ODataConnectedService.csproj b/src/ODataConnectedService.csproj
index 609c7a46..50822301 100644
--- a/src/ODataConnectedService.csproj
+++ b/src/ODataConnectedService.csproj
@@ -190,6 +190,7 @@
     <Compile Include="CodeGeneration\V4CodeGenDescriptor.cs" />
     <Compile Include="Common\Constants.cs" />
     <Compile Include="Common\EdmHelper.cs" />
+    <Compile Include="Common\ExtensionMethods.cs" />
     <Compile Include="Common\ExtensionsHelper.cs" />
     <Compile Include="Common\ProjectHelper.cs" />
     <Compile Include="Common\UserSettingsPersistenceHelper.cs" />
diff --git a/src/ODataConnectedServiceWizard.cs b/src/ODataConnectedServiceWizard.cs
index c0036bcf..94e08f0d 100644
--- a/src/ODataConnectedServiceWizard.cs
+++ b/src/ODataConnectedServiceWizard.cs
@@ -32,15 +32,13 @@ internal class ODataConnectedServiceWizard : ConnectedServiceWizard
 
         public ConnectedServiceProviderContext Context { get; set; }
 
-        public ODataConnectedServiceInstance ServiceInstance => this.serviceInstance ?? (this.serviceInstance = new ODataConnectedServiceInstance());
+        public ODataConnectedServiceInstance ServiceInstance => serviceInstance ?? (serviceInstance = new ODataConnectedServiceInstance());
 
-        public Version EdmxVersion => this.ConfigODataEndpointViewModel.EdmxVersion;
+        public Version EdmxVersion => ConfigODataEndpointViewModel.EdmxVersion;
 
-        public UserSettings UserSettings { get; }
+        public UserSettings UserSettings { get; internal set; }
 
-        private readonly ServiceConfigurationV4 _serviceConfig;
-
-        public ServiceConfigurationV4 ServiceConfig { get { return _serviceConfig; } }
+        public ServiceConfigurationV4 ServiceConfig { get; private set; }
 
         internal string ProcessedEndpointForOperationImports;
 
@@ -48,74 +46,73 @@ internal class ODataConnectedServiceWizard : ConnectedServiceWizard
 
         public ODataConnectedServiceWizard(ConnectedServiceProviderContext context)
         {
-            this.Context = context;
-            this.UserSettings = UserSettings.Load(context?.Logger);
+            Context = context;
+            // We only use most recently used endpoints from the config file saved in user's isolated storage
+            // The UserSettings constructor will load those endpoints
+            UserSettings = new UserSettings(context?.Logger);
 
-            // Since ServiceConfigurationV4 is a derived type of ServiceConfiguration. So we can deserialize a ServiceConfiguration into a ServiceConfigurationV4.
-            this._serviceConfig = this.Context?.GetExtendedDesignerData<ServiceConfigurationV4>();
+            // Since ServiceConfigurationV4 is a derived type of ServiceConfiguration,
+            // we can deserialize a ServiceConfiguration into a ServiceConfigurationV4.
+            ServiceConfig = Context?.GetExtendedDesignerData<ServiceConfigurationV4>();
 
-            ConfigODataEndpointViewModel = new ConfigODataEndpointViewModel(this.UserSettings, this);
-            AdvancedSettingsViewModel = new AdvancedSettingsViewModel(this.UserSettings);
-            SchemaTypesViewModel = new SchemaTypesViewModel(this.UserSettings);
+            ConfigODataEndpointViewModel = new ConfigODataEndpointViewModel(UserSettings);
+            AdvancedSettingsViewModel = new AdvancedSettingsViewModel(UserSettings);
+            SchemaTypesViewModel = new SchemaTypesViewModel(UserSettings);
+            OperationImportsViewModel = new OperationImportsViewModel(UserSettings);
 
-            OperationImportsViewModel = new OperationImportsViewModel(this.UserSettings);
             OperationImportsViewModel.PageEntering += OperationImportsViewModel_PageEntering;
-
             SchemaTypesViewModel.PageEntering += SchemaTypeSelectionViewModel_PageEntering;
             SchemaTypesViewModel.PageLeaving += SchemaTypeSelectionViewModel_PageLeaving;
-            if (this.Context != null && this.Context.IsUpdating)
+
+            if (Context != null && Context.IsUpdating)
             {
-                ConfigODataEndpointViewModel.Endpoint = this._serviceConfig?.Endpoint;
-                ConfigODataEndpointViewModel.EdmxVersion = this._serviceConfig?.EdmxVersion;
-                ConfigODataEndpointViewModel.ServiceName = this._serviceConfig?.ServiceName;
-                ConfigODataEndpointViewModel.CustomHttpHeaders = this._serviceConfig?.CustomHttpHeaders;
+                LoadUserSettingsFromServiceConfig();
+                ConfigODataEndpointViewModel.EdmxVersion = ServiceConfig?.EdmxVersion;
 
                 // Restore the main settings to UI elements.
                 ConfigODataEndpointViewModel.PageEntering += ConfigODataEndpointViewModel_PageEntering;
-
                 // The ViewModel should always be filled otherwise if the wizard is completed without visiting this page the generated code becomes wrong
                 AdvancedSettingsViewModel_PageEntering(AdvancedSettingsViewModel, EventArgs.Empty);
-
                 // Restore the advanced settings to UI elements.
                 AdvancedSettingsViewModel.PageEntering += AdvancedSettingsViewModel_PageEntering;
             }
 
-            this.Pages.Add(ConfigODataEndpointViewModel);
-            this.Pages.Add(SchemaTypesViewModel);
-            this.Pages.Add(OperationImportsViewModel);
-            this.Pages.Add(AdvancedSettingsViewModel);
-            this.IsFinishEnabled = true;
+            Pages.Add(ConfigODataEndpointViewModel);
+            Pages.Add(SchemaTypesViewModel);
+            Pages.Add(OperationImportsViewModel);
+            Pages.Add(AdvancedSettingsViewModel);
+            IsFinishEnabled = true;
         }
 
         public override async Task<ConnectedServiceInstance> GetFinishedServiceInstanceAsync()
         {
             // ensure that the data has been loaded from wizard pages and saved to UserSettings
-            if (this.Context.IsUpdating)
+            if (Context.IsUpdating)
             {
-                if (!this.OperationImportsViewModel.IsEntered)
+                if (!OperationImportsViewModel.IsEntered)
                 {
                     await OperationImportsViewModel.OnPageEnteringAsync(null).ConfigureAwait(false);
                     await OperationImportsViewModel.OnPageLeavingAsync(null).ConfigureAwait(false);
                 }
 
-                if (!this.SchemaTypesViewModel.IsEntered)
+                if (!SchemaTypesViewModel.IsEntered)
                 {
                     await SchemaTypesViewModel.OnPageEnteringAsync(null).ConfigureAwait(false);
                     await SchemaTypesViewModel.OnPageLeavingAsync(null).ConfigureAwait(false);
                 }
 
-                if (!this.AdvancedSettingsViewModel.IsEntered)
+                if (!AdvancedSettingsViewModel.IsEntered)
                 {
                     await AdvancedSettingsViewModel.OnPageEnteringAsync(null).ConfigureAwait(false);
                     await AdvancedSettingsViewModel.OnPageLeavingAsync(null).ConfigureAwait(false);
                 }
             }
 
-            this.UserSettings.Save();
-            this.ServiceInstance.InstanceId = AdvancedSettingsViewModel.GeneratedFileNamePrefix;
-            this.ServiceInstance.Name = ConfigODataEndpointViewModel.ServiceName;
-            this.ServiceInstance.MetadataTempFilePath = ConfigODataEndpointViewModel.MetadataTempPath;
-            this.ServiceInstance.ServiceConfig = this.CreateServiceConfiguration();
+            UserSettings.Save();
+            ServiceInstance.InstanceId = UserSettings.GeneratedFileNamePrefix;
+            ServiceInstance.Name = UserSettings.ServiceName;
+            ServiceInstance.MetadataTempFilePath = ConfigODataEndpointViewModel.MetadataTempPath;
+            ServiceInstance.ServiceConfig = CreateServiceConfiguration();
 
             return await Task.FromResult<ConnectedServiceInstance>(ServiceInstance).ConfigureAwait(false);
         }
@@ -127,50 +124,38 @@ public override async Task<ConnectedServiceInstance> GetFinishedServiceInstanceA
         private ServiceConfiguration CreateServiceConfiguration()
         {
             ServiceConfiguration serviceConfiguration;
-            if (ConfigODataEndpointViewModel.EdmxVersion == Common.Constants.EdmxVersion4)
+
+            if (ConfigODataEndpointViewModel.EdmxVersion == Constants.EdmxVersion4)
             {
-                var serviceConfigurationV4 = new ServiceConfigurationV4
-                {
-                    ExcludedOperationImports = OperationImportsViewModel.ExcludedOperationImportsNames.ToList(),
-                    ExcludedBoundOperations = SchemaTypesViewModel.ExcludedBoundOperationsNames.ToList(),
-                    IgnoreUnexpectedElementsAndAttributes =
-                        AdvancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes,
-                    EnableNamingAlias = AdvancedSettingsViewModel.EnableNamingAlias,
-                    IncludeT4File = AdvancedSettingsViewModel.IncludeT4File,
-                    OpenGeneratedFilesInIDE = AdvancedSettingsViewModel.OpenGeneratedFilesInIDE
-                };
+                var serviceConfigurationV4 = new ServiceConfigurationV4();
+                serviceConfigurationV4.CopyPropertiesFrom(UserSettings);
+
+                serviceConfigurationV4.ExcludedOperationImports = OperationImportsViewModel.ExcludedOperationImportsNames.ToList();
+                serviceConfigurationV4.ExcludedBoundOperations = SchemaTypesViewModel.ExcludedBoundOperationsNames.ToList();
+
                 serviceConfiguration = serviceConfigurationV4;
             }
             else
             {
                 serviceConfiguration = new ServiceConfiguration();
+
+                serviceConfiguration.CopyPropertiesFrom(UserSettings);
             }
 
             serviceConfiguration.ExcludedSchemaTypes = SchemaTypesViewModel.ExcludedSchemaTypeNames.ToList();
-            serviceConfiguration.ServiceName = ConfigODataEndpointViewModel.ServiceName;
-            serviceConfiguration.Endpoint = ConfigODataEndpointViewModel.Endpoint;
             serviceConfiguration.EdmxVersion = ConfigODataEndpointViewModel.EdmxVersion;
-            serviceConfiguration.CustomHttpHeaders = ConfigODataEndpointViewModel.CustomHttpHeaders;
-            serviceConfiguration.IncludeWebProxy = ConfigODataEndpointViewModel.IncludeWebProxy;
-            serviceConfiguration.WebProxyHost = ConfigODataEndpointViewModel.WebProxyHost;
-            serviceConfiguration.IncludeWebProxyNetworkCredentials = ConfigODataEndpointViewModel.IncludeWebProxyNetworkCredentials;
-            serviceConfiguration.WebProxyNetworkCredentialsUsername = ConfigODataEndpointViewModel.WebProxyNetworkCredentialsUsername;
-            serviceConfiguration.WebProxyNetworkCredentialsPassword = ConfigODataEndpointViewModel.WebProxyNetworkCredentialsPassword;
-            serviceConfiguration.WebProxyNetworkCredentialsDomain = ConfigODataEndpointViewModel.WebProxyNetworkCredentialsDomain;
-            serviceConfiguration.IncludeCustomHeaders = ConfigODataEndpointViewModel.IncludeCustomHeaders;
-            serviceConfiguration.UseDataServiceCollection = AdvancedSettingsViewModel.UseDataServiceCollection;
-            serviceConfiguration.GeneratedFileNamePrefix = AdvancedSettingsViewModel.GeneratedFileNamePrefix;
-            serviceConfiguration.UseNamespacePrefix = AdvancedSettingsViewModel.UseNamespacePrefix;
-            serviceConfiguration.MakeTypesInternal = AdvancedSettingsViewModel.MakeTypesInternal;
-            serviceConfiguration.OpenGeneratedFilesInIDE = AdvancedSettingsViewModel.OpenGeneratedFilesInIDE;
-            serviceConfiguration.GenerateMultipleFiles = AdvancedSettingsViewModel.GenerateMultipleFiles;
-
-            if (AdvancedSettingsViewModel.UseNamespacePrefix && !string.IsNullOrEmpty(AdvancedSettingsViewModel.NamespacePrefix))
+
+            return serviceConfiguration;
+        }
+
+        private void LoadUserSettingsFromServiceConfig()
+        {
+            if (ServiceConfig == null)
             {
-                serviceConfiguration.NamespacePrefix = AdvancedSettingsViewModel.NamespacePrefix;
+                return;
             }
 
-            return serviceConfiguration;
+            UserSettings.CopyPropertiesFrom(ServiceConfig);
         }
 
         #region "Event Handlers"
@@ -183,19 +168,9 @@ public void ConfigODataEndpointViewModel_PageEntering(object sender, EventArgs a
                 {
                     configOdataView.Endpoint.IsEnabled = false;
                     configOdataView.OpenConnectedServiceJsonFileButton.IsEnabled = false;
-                    configOdataView.OpenEndpointFileButton.IsEnabled = !this._serviceConfig.Endpoint.StartsWith("http", StringComparison.OrdinalIgnoreCase);
+                    configOdataView.OpenEndpointFileButton.IsEnabled = !ServiceConfig.Endpoint.StartsWith("http", StringComparison.OrdinalIgnoreCase);
                     configOdataView.ServiceName.IsEnabled = false;
                 }
-
-                configOdataViewModel.IncludeCustomHeaders = this._serviceConfig.IncludeCustomHeaders;
-                configOdataViewModel.IncludeWebProxy = this._serviceConfig.IncludeWebProxy;
-                configOdataViewModel.WebProxyHost = this._serviceConfig.WebProxyHost;
-                configOdataViewModel.IncludeWebProxyNetworkCredentials = this._serviceConfig.IncludeWebProxyNetworkCredentials;
-                configOdataViewModel.WebProxyNetworkCredentialsDomain = this._serviceConfig.WebProxyNetworkCredentialsDomain;
-
-                // don't accept any credentials from the restored settings
-                configOdataViewModel.WebProxyNetworkCredentialsUsername = null;
-                configOdataViewModel.WebProxyNetworkCredentialsPassword = null;
             }
         }
 
@@ -205,22 +180,12 @@ public void AdvancedSettingsViewModel_PageEntering(object sender, EventArgs args
             {
                 if (advancedSettingsViewModel.View is AdvancedSettings advancedSettings)
                 {
-                    advancedSettingsViewModel.GeneratedFileNamePrefix = this._serviceConfig.GeneratedFileNamePrefix;
-                    advancedSettings.ReferenceFileName.IsEnabled = !this.Context.IsUpdating;
-                    advancedSettingsViewModel.UseNamespacePrefix = this._serviceConfig.UseNamespacePrefix;
-                    advancedSettingsViewModel.NamespacePrefix = this._serviceConfig.NamespacePrefix ?? Common.Constants.DefaultReferenceFileName;
-                    advancedSettingsViewModel.UseDataServiceCollection = this._serviceConfig.UseDataServiceCollection;
-                    advancedSettingsViewModel.OpenGeneratedFilesInIDE = this._serviceConfig.OpenGeneratedFilesInIDE;
-                    advancedSettingsViewModel.GenerateMultipleFiles = this._serviceConfig.GenerateMultipleFiles;
-                    advancedSettings.GenerateMultipleFiles.IsEnabled = !this.Context.IsUpdating;
-
-                    if (this._serviceConfig.EdmxVersion == Common.Constants.EdmxVersion4)
+                    advancedSettings.ReferenceFileName.IsEnabled = !Context.IsUpdating;
+                    advancedSettings.GenerateMultipleFiles.IsEnabled = !Context.IsUpdating;
+
+                    if (ServiceConfig.EdmxVersion == Constants.EdmxVersion4)
                     {
-                        advancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes = this._serviceConfig.IgnoreUnexpectedElementsAndAttributes;
-                        advancedSettingsViewModel.EnableNamingAlias = this._serviceConfig.EnableNamingAlias;
-                        advancedSettingsViewModel.IncludeT4File = this._serviceConfig.IncludeT4File;
-                        advancedSettingsViewModel.MakeTypesInternal = this._serviceConfig.MakeTypesInternal;
-                        advancedSettings.IncludeT4File.IsEnabled = !this.Context.IsUpdating;
+                        advancedSettings.IncludeT4File.IsEnabled = !Context.IsUpdating;
                     }
                 }
             }
@@ -230,7 +195,7 @@ public void OperationImportsViewModel_PageEntering(object sender, EventArgs args
         {
             if (sender is OperationImportsViewModel operationImportsViewModel)
             {
-                if (this.ProcessedEndpointForOperationImports != ConfigODataEndpointViewModel.Endpoint)
+                if (ProcessedEndpointForOperationImports != UserSettings.Endpoint)
                 {
                     if (ConfigODataEndpointViewModel.EdmxVersion != Constants.EdmxVersion4)
                     {
@@ -245,11 +210,11 @@ public void OperationImportsViewModel_PageEntering(object sender, EventArgs args
 
                     if (Context.IsUpdating)
                     {
-                        operationImportsViewModel.ExcludeOperationImports(this._serviceConfig?.ExcludedOperationImports ?? Enumerable.Empty<string>());
+                        operationImportsViewModel.ExcludeOperationImports(ServiceConfig?.ExcludedOperationImports ?? Enumerable.Empty<string>());
                     }
                 }
 
-                this.ProcessedEndpointForOperationImports = ConfigODataEndpointViewModel.Endpoint;
+                ProcessedEndpointForOperationImports = UserSettings.Endpoint;
             }
         }
 
@@ -257,7 +222,7 @@ public void SchemaTypeSelectionViewModel_PageEntering(object sender, EventArgs a
         {
             if (sender is SchemaTypesViewModel entityTypeViewModel)
             {
-                if (this.ProcessedEndpointForSchemaTypes != ConfigODataEndpointViewModel.Endpoint)
+                if (ProcessedEndpointForSchemaTypes != UserSettings.Endpoint)
                 {
                     var model = EdmHelper.GetEdmModelFromFile(ConfigODataEndpointViewModel.MetadataTempPath);
                     var entityTypes = EdmHelper.GetSchemaTypes(model);
@@ -267,12 +232,12 @@ public void SchemaTypeSelectionViewModel_PageEntering(object sender, EventArgs a
                     if (Context.IsUpdating)
                     {
                         entityTypeViewModel.ExcludeSchemaTypes(
-                            this._serviceConfig?.ExcludedSchemaTypes ?? Enumerable.Empty<string>(),
-                            this._serviceConfig?.ExcludedBoundOperations ?? Enumerable.Empty<string>());
+                            ServiceConfig?.ExcludedSchemaTypes ?? Enumerable.Empty<string>(),
+                            ServiceConfig?.ExcludedBoundOperations ?? Enumerable.Empty<string>());
                     }
                 }
 
-                this.ProcessedEndpointForSchemaTypes = ConfigODataEndpointViewModel.Endpoint;
+                ProcessedEndpointForSchemaTypes = UserSettings.Endpoint;
             }
         }
 
@@ -320,34 +285,34 @@ protected override void Dispose(bool disposing)
             {
                 if (disposing)
                 {
-                    if (this.AdvancedSettingsViewModel != null)
+                    if (AdvancedSettingsViewModel != null)
                     {
-                        this.AdvancedSettingsViewModel.Dispose();
-                        this.AdvancedSettingsViewModel = null;
+                        AdvancedSettingsViewModel.Dispose();
+                        AdvancedSettingsViewModel = null;
                     }
 
-                    if (this.OperationImportsViewModel != null)
+                    if (OperationImportsViewModel != null)
                     {
-                        this.OperationImportsViewModel.Dispose();
+                        OperationImportsViewModel.Dispose();
                         OperationImportsViewModel = null;
                     }
 
-                    if (this.SchemaTypesViewModel != null)
+                    if (SchemaTypesViewModel != null)
                     {
-                        this.SchemaTypesViewModel.Dispose();
-                        this.SchemaTypesViewModel = null;
+                        SchemaTypesViewModel.Dispose();
+                        SchemaTypesViewModel = null;
                     }
 
-                    if (this.ConfigODataEndpointViewModel != null)
+                    if (ConfigODataEndpointViewModel != null)
                     {
-                        this.ConfigODataEndpointViewModel.Dispose();
-                        this.ConfigODataEndpointViewModel = null;
+                        ConfigODataEndpointViewModel.Dispose();
+                        ConfigODataEndpointViewModel = null;
                     }
 
-                    if (this.serviceInstance != null)
+                    if (serviceInstance != null)
                     {
-                        this.serviceInstance.Dispose();
-                        this.serviceInstance = null;
+                        serviceInstance.Dispose();
+                        serviceInstance = null;
                     }
                 }
             }
diff --git a/src/Properties/AssemblyInfo.cs b/src/Properties/AssemblyInfo.cs
index 2d8190b0..9cc3cc91 100644
--- a/src/Properties/AssemblyInfo.cs
+++ b/src/Properties/AssemblyInfo.cs
@@ -39,8 +39,8 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.11.2.0")]
-[assembly: AssemblyFileVersion("0.11.2.0")]
+[assembly: AssemblyVersion("0.11.1.0")]
+[assembly: AssemblyFileVersion("0.11.1.0")]
 [assembly: NeutralResourcesLanguageAttribute("en")]
 
 [assembly: InternalsVisibleTo("ODataConnectedService.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001003d2fbcc3c5595b4212227a5ca0fb1c45cb9c942096831420563dc169dd847a8a5fe068170bd10802dea50bc4d8342c1f8aa2ab9f27e3ceccdb21ce8c1415c3ea33eb7bc09059ca50b3e8607fa34bb9925466525ceffc3edac84ac1863afc28ef935c8db7a6430771fa41aa3de8a8d399990b02cae85e834e5d29d2cc0109b8cb")]
diff --git a/src/ViewModels/AdvancedSettingsViewModel.cs b/src/ViewModels/AdvancedSettingsViewModel.cs
index 016f1bc9..da23019b 100644
--- a/src/ViewModels/AdvancedSettingsViewModel.cs
+++ b/src/ViewModels/AdvancedSettingsViewModel.cs
@@ -15,27 +15,7 @@ namespace Microsoft.OData.ConnectedService.ViewModels
 {
     internal class AdvancedSettingsViewModel : ConnectedServiceWizardPage
     {
-        public bool UseDataServiceCollection { get; set; }
-
-        public bool UseNamespacePrefix { get; set; }
-
-        public string NamespacePrefix { get; set; }
-
-        public bool EnableNamingAlias { get; set; }
-
-        public bool IgnoreUnexpectedElementsAndAttributes { get; set; }
-
-        public string GeneratedFileNamePrefix { get; set; }
-
-        public bool IncludeT4File { get; set; }
-
-        public bool MakeTypesInternal { get; set; }
-
-        public bool OpenGeneratedFilesInIDE { get; set; }
-
-        public bool GenerateMultipleFiles { get; set; }
-
-        public UserSettings UserSettings { get; set; }
+        public UserSettings UserSettings { get; internal set; }
 
         internal bool IsEntered;
 
@@ -45,8 +25,6 @@ public AdvancedSettingsViewModel(UserSettings userSettings) : base()
             this.Description = "Advanced settings for generating client proxy";
             this.Legend = "Settings";
             this.UserSettings = userSettings;
-            this.GeneratedFileNamePrefix = Common.Constants.DefaultReferenceFileName;
-            this.NamespacePrefix = Common.Constants.DefaultReferenceFileName;
         }
 
         public event EventHandler<EventArgs> PageEntering;
@@ -61,42 +39,7 @@ public override async Task OnPageEnteringAsync(WizardEnteringArgs args)
 
         public override Task<PageNavigationResult> OnPageLeavingAsync(WizardLeavingArgs args)
         {
-            SaveToUserSettings();
             return base.OnPageLeavingAsync(args);
         }
-
-        private void SaveToUserSettings()
-        {
-            if (this.UserSettings != null)
-            {
-                UserSettings.GeneratedFileNamePrefix = this.GeneratedFileNamePrefix;
-                UserSettings.OpenGeneratedFilesInIDE = this.OpenGeneratedFilesInIDE;
-                UserSettings.UseNamespacePrefix = this.UseNamespacePrefix;
-                UserSettings.NamespacePrefix = this.NamespacePrefix;
-                UserSettings.UseDataServiceCollection = this.UseDataServiceCollection;
-                UserSettings.MakeTypesInternal = this.MakeTypesInternal;
-                UserSettings.IncludeT4File = this.IncludeT4File;
-                UserSettings.IgnoreUnexpectedElementsAndAttributes = this.IgnoreUnexpectedElementsAndAttributes;
-                UserSettings.EnableNamingAlias = this.EnableNamingAlias;
-                UserSettings.GenerateMultipleFiles = this.GenerateMultipleFiles;
-            }
-        }
-
-        public void LoadFromUserSettings()
-        {
-            if (UserSettings != null)
-            {
-                this.GeneratedFileNamePrefix = UserSettings.GeneratedFileNamePrefix ?? Common.Constants.DefaultReferenceFileName;
-                this.OpenGeneratedFilesInIDE = UserSettings.OpenGeneratedFilesInIDE;
-                this.UseNamespacePrefix = UserSettings.UseNamespacePrefix;
-                this.NamespacePrefix = UserSettings.NamespacePrefix ?? Common.Constants.DefaultReferenceFileName;
-                this.UseDataServiceCollection = UserSettings.UseDataServiceCollection;
-                this.MakeTypesInternal = UserSettings.MakeTypesInternal;
-                this.IncludeT4File = UserSettings.IncludeT4File;
-                this.IgnoreUnexpectedElementsAndAttributes = UserSettings.IgnoreUnexpectedElementsAndAttributes;
-                this.EnableNamingAlias = UserSettings.EnableNamingAlias;
-                this.GenerateMultipleFiles = UserSettings.GenerateMultipleFiles;
-            }
-        }
     }
 }
diff --git a/src/ViewModels/ConfigODataEndpointViewModel.cs b/src/ViewModels/ConfigODataEndpointViewModel.cs
index e5b4b656..4b9a5f0e 100644
--- a/src/ViewModels/ConfigODataEndpointViewModel.cs
+++ b/src/ViewModels/ConfigODataEndpointViewModel.cs
@@ -20,44 +20,20 @@ namespace Microsoft.OData.ConnectedService.ViewModels
 {
     internal class ConfigODataEndpointViewModel : ConnectedServiceWizardPage
     {
-        public string Endpoint { get; set; }
-
-        public string ServiceName { get; set; }
-
         public Version EdmxVersion { get; set; }
 
         public string MetadataTempPath { get; set; }
 
-        public string CustomHttpHeaders { get; set; }
-
-        public UserSettings UserSettings { get; set; }
-
-        public bool IncludeWebProxy { get; set; }
-
-        public string WebProxyHost { get; set; }
-
-        public bool IncludeWebProxyNetworkCredentials { get; set; }
-
-        public string WebProxyNetworkCredentialsUsername { get; set; }
-
-        public string WebProxyNetworkCredentialsPassword { get; set; }
-
-        public string WebProxyNetworkCredentialsDomain { get; set; }
-
-        public bool IncludeCustomHeaders { get; set; }
+        public UserSettings UserSettings { get; internal set; }
 
         public event EventHandler<EventArgs> PageEntering;
 
-        public ODataConnectedServiceWizard ServiceWizard { get; set; }
-
-        public ConfigODataEndpointViewModel(UserSettings userSettings, ODataConnectedServiceWizard serviceWizard) : base()
+        public ConfigODataEndpointViewModel(UserSettings userSettings) : base()
         {
             this.Title = "Configure endpoint";
             this.Description = "Enter or choose an OData service endpoint to begin";
             this.Legend = "Endpoint";
-            this.ServiceWizard = serviceWizard;
             this.UserSettings = userSettings;
-            this.ServiceName = Constants.DefaultServiceName;
         }
         public override async Task OnPageEnteringAsync(WizardEnteringArgs args)
         {
@@ -67,14 +43,14 @@ public override async Task OnPageEnteringAsync(WizardEnteringArgs args)
         }
 
         public event EventHandler<EventArgs> PageLeaving;
+
         public override Task<PageNavigationResult> OnPageLeavingAsync(WizardLeavingArgs args)
         {
-            SaveToUserSettings();
-            var wizard = this.Wizard as ODataConnectedServiceWizard;
-            UserSettings.AddToTopOfMruList(wizard?.UserSettings?.MruEndpoints, this.Endpoint);
             try
             {
                 this.MetadataTempPath = GetMetadata(out var version);
+                // Makes sense to add MRU endpoint at this point since GetMetadata manipulates UserSettings.Endpoint
+                UserSettings.AddMruEndpoint(UserSettings.Endpoint);
                 this.EdmxVersion = version;
                 PageLeaving?.Invoke(this, EventArgs.Empty);
                 return base.OnPageLeavingAsync(args);
@@ -93,28 +69,28 @@ public override Task<PageNavigationResult> OnPageLeavingAsync(WizardLeavingArgs
 
         internal string GetMetadata(out Version edmxVersion)
         {
-            if (string.IsNullOrEmpty(this.Endpoint))
+            if (string.IsNullOrEmpty(UserSettings.Endpoint))
             {
                 throw new ArgumentNullException("OData Service Endpoint", string.Format(CultureInfo.InvariantCulture, Constants.InputServiceEndpointMsg));
             }
 
-            if (this.Endpoint.StartsWith("https:", StringComparison.Ordinal)
-                || this.Endpoint.StartsWith("http", StringComparison.Ordinal))
+            if (UserSettings.Endpoint.StartsWith("https:", StringComparison.Ordinal)
+                || UserSettings.Endpoint.StartsWith("http", StringComparison.Ordinal))
             {
-                if (!this.Endpoint.EndsWith("$metadata", StringComparison.Ordinal))
+                if (!UserSettings.Endpoint.EndsWith("$metadata", StringComparison.Ordinal))
                 {
-                    this.Endpoint = this.Endpoint.TrimEnd('/') + "/$metadata";
+                    UserSettings.Endpoint = UserSettings.Endpoint.TrimEnd('/') + "/$metadata";
                 }
             }
 
             Stream metadataStream;
-            var metadataUri = new Uri(this.Endpoint);
+            var metadataUri = new Uri(UserSettings.Endpoint);
             if (!metadataUri.IsFile)
             {
                 var webRequest = (HttpWebRequest)WebRequest.Create(metadataUri);
-                if (this.CustomHttpHeaders != null)
+                if (UserSettings.CustomHttpHeaders != null)
                 {
-                    var headerElements = this.CustomHttpHeaders.Split(new [] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
+                    var headerElements = UserSettings.CustomHttpHeaders.Split(new [] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                     foreach (var headerElement in headerElements)
                     {
                         // Trim header for empty spaces
@@ -123,12 +99,15 @@ internal string GetMetadata(out Version edmxVersion)
                     }
                 }
 
-                if (IncludeWebProxy)
+                if (UserSettings.IncludeWebProxy)
                 {
-                    var proxy = new WebProxy(WebProxyHost);
-                    if (IncludeWebProxyNetworkCredentials)
+                    var proxy = new WebProxy(UserSettings.WebProxyHost);
+                    if (UserSettings.IncludeWebProxyNetworkCredentials)
                     {
-                        proxy.Credentials = new NetworkCredential(WebProxyNetworkCredentialsUsername, WebProxyNetworkCredentialsPassword, WebProxyNetworkCredentialsDomain);
+                        proxy.Credentials = new NetworkCredential(
+                            UserSettings.WebProxyNetworkCredentialsUsername,
+                            UserSettings.WebProxyNetworkCredentialsPassword,
+                            UserSettings.WebProxyNetworkCredentialsDomain);
                     }
 
                     webRequest.Proxy = proxy;
@@ -174,7 +153,7 @@ internal string GetMetadata(out Version edmxVersion)
             }
             catch (WebException e)
             {
-                throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot access {0}", this.Endpoint), e);
+                throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot access {0}", UserSettings.Endpoint), e);
             }
             finally
             {
@@ -182,41 +161,6 @@ internal string GetMetadata(out Version edmxVersion)
             }
         }
 
-        private void SaveToUserSettings()
-        {
-            if (this.UserSettings != null)
-            {
-                UserSettings.ServiceName = this.ServiceName;
-                UserSettings.Endpoint = this.Endpoint;
-                UserSettings.WebProxyHost = this.WebProxyHost;
-                UserSettings.CustomHttpHeaders = this.CustomHttpHeaders;
-                UserSettings.WebProxyNetworkCredentialsDomain = this.WebProxyNetworkCredentialsDomain;
-                UserSettings.WebProxyNetworkCredentialsPassword = this.WebProxyNetworkCredentialsPassword;
-                UserSettings.WebProxyNetworkCredentialsUsername = this.WebProxyNetworkCredentialsUsername;
-                UserSettings.IncludeCustomHeaders = this.IncludeCustomHeaders;
-                UserSettings.IncludeWebProxy = this.IncludeWebProxy;
-                UserSettings.IncludeWebProxyNetworkCredentials = this.IncludeWebProxyNetworkCredentials;
-            }
-        }
-
-        public void LoadFromUserSettings()
-        {
-            if (this.UserSettings != null)
-            {
-                this.ServiceName = UserSettings.ServiceName ?? Constants.DefaultServiceName;
-                this.Endpoint = UserSettings.Endpoint;
-                this.WebProxyHost = UserSettings.WebProxyHost;
-                this.IncludeWebProxy = UserSettings.IncludeWebProxy;
-                this.IncludeCustomHeaders = UserSettings.IncludeCustomHeaders;
-                this.CustomHttpHeaders = UserSettings.CustomHttpHeaders;
-                this.IncludeWebProxyNetworkCredentials = UserSettings.IncludeWebProxyNetworkCredentials;
-                this.WebProxyNetworkCredentialsDomain = UserSettings.WebProxyNetworkCredentialsDomain;
-                this.WebProxyNetworkCredentialsPassword = UserSettings.WebProxyNetworkCredentialsPassword;
-                this.WebProxyNetworkCredentialsUsername = UserSettings.WebProxyNetworkCredentialsUsername;
-                this.View = new ConfigODataEndpoint { DataContext = this };
-            }
-        }
-
         private void DisposeStream(Stream stream)
         {
             stream?.Dispose();
diff --git a/src/ViewModels/OperationImportsViewModel.cs b/src/ViewModels/OperationImportsViewModel.cs
index 50917949..d72032f4 100644
--- a/src/ViewModels/OperationImportsViewModel.cs
+++ b/src/ViewModels/OperationImportsViewModel.cs
@@ -29,7 +29,7 @@ internal class OperationImportsViewModel: ConnectedServiceWizardPage
         /// <remarks>
         /// <see cref="Models.UserSettings"/>
         /// </remarks>
-        public UserSettings UserSettings { get; set; }
+        public UserSettings UserSettings { get; internal set; }
 
         private long _operationImportsCount = 0;
 
diff --git a/src/Views/AdvancedSettings.xaml b/src/Views/AdvancedSettings.xaml
index 221e7604..523418ca 100644
--- a/src/Views/AdvancedSettings.xaml
+++ b/src/Views/AdvancedSettings.xaml
@@ -15,7 +15,7 @@
 
             <TextBlock x:Name="ReferenceFileNameLabel" Text="Enter the file name (without extension):"
                            HorizontalAlignment="Left" Margin="0, 5, 0, 0"/>
-            <TextBox x:Name="ReferenceFileName" Text="{Binding GeneratedFileNamePrefix}"
+            <TextBox x:Name="ReferenceFileName" Text="{Binding UserSettings.GeneratedFileNamePrefix, Mode=TwoWay}"
                          HorizontalAlignment="Left" TextWrapping="Wrap" VerticalAlignment="Bottom" Width="250" Margin="20, 5, 0, 0"/>
             <StackPanel x:Name="AdvancedSettingsHyperLinkPanel">
                 <TextBlock x:Name="Label" TextWrapping="WrapWithOverflow" Margin="0, 20, 40, 0">
@@ -28,33 +28,33 @@
         </StackPanel>
         <StackPanel x:Name="AdvancedSettingsPanel">
             <StackPanel HorizontalAlignment="Left" Margin="10, 0, 0, 0" VerticalAlignment="Top">
-                <CheckBox x:Name="UseNamespacePrefix" IsChecked="{Binding UseNamespacePrefix}"
+                <CheckBox x:Name="UseNamespacePrefix" IsChecked="{Binding UserSettings.UseNamespacePrefix, Mode=TwoWay}"
                           HorizontalAlignment="Left" VerticalAlignment="Bottom" Margin="0,5">
                     <TextBlock TextWrapping="Wrap" Margin="0, 0, 40, 0">
                         Use a custom namespace (It will replace the original namespace in the metadata document, unless the model has several namespaces.)
                     </TextBlock>
                 </CheckBox>
-                <TextBox x:Name="NamespacePrefix" Text="{Binding NamespacePrefix}"
+                <TextBox x:Name="NamespacePrefix" Text="{Binding Path=UserSettings.NamespacePrefix, Mode=TwoWay}"
                          HorizontalAlignment="Left" TextWrapping="Wrap" VerticalAlignment="Center" Width="250" Margin="20, 0, 0, 5"/>
-                <CheckBox x:Name="UseDSC" Content="Enable entity and property tracking" IsChecked="{Binding UseDataServiceCollection}"
+                <CheckBox x:Name="UseDSC" Content="Enable entity and property tracking" IsChecked="{Binding Path=UserSettings.UseDataServiceCollection, Mode=TwoWay}"
                           HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0, 5, 0, 0" />
             </StackPanel>
             <StackPanel x:Name="AdvancedSettingsForv4" HorizontalAlignment="Left" Margin="10, 5, 0, 0" VerticalAlignment="Top">
-                <CheckBox x:Name="EnableCamelCase" Content="Use c# casing style" IsChecked="{Binding EnableNamingAlias}"
+                <CheckBox x:Name="EnableCamelCase" Content="Use c# casing style" IsChecked="{Binding Path=UserSettings.EnableNamingAlias, Mode=TwoWay}"
             		HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0, 5"/>
-                <CheckBox x:Name="IgnoreUnknownAttributeOrElement" IsChecked="{Binding IgnoreUnexpectedElementsAndAttributes}"
+                <CheckBox x:Name="IgnoreUnknownAttributeOrElement" IsChecked="{Binding Path=UserSettings.IgnoreUnexpectedElementsAndAttributes, Mode=TwoWay}"
             		HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0, 5">
                     <TextBlock TextWrapping="Wrap" Margin="0, 0, 40, 0">Ignore unknown elements (Whether to ignore unexpected elements and attributes in the metadata document and generate the client code if any.)</TextBlock>
                 </CheckBox>
-                <CheckBox x:Name="MakeTypesInternal" IsChecked="{Binding MakeTypesInternal}"
+                <CheckBox x:Name="MakeTypesInternal" IsChecked="{Binding Path=UserSettings.MakeTypesInternal, Mode=TwoWay}"
                     HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0, 5">
                     <TextBlock TextWrapping="Wrap" Margin="0, 0, 40, 0">Make generated types internal (Enable this if you don't want to expose the generated types outside of your assembly.)</TextBlock>
                 </CheckBox>
-                <CheckBox x:Name="IncludeT4File" Content="Add code templates (Whether to include the T4 files into this project.)" IsChecked="{Binding IncludeT4File}"
+                <CheckBox x:Name="IncludeT4File" Content="Add code templates (Whether to include the T4 files into this project.)" IsChecked="{Binding Path=UserSettings.IncludeT4File, Mode=TwoWay}"
             		HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0, 15" FontWeight="Medium"/>
-                <CheckBox x:Name="OpenGeneratedFilesInIDE" Content="Open generated files in the IDE when generation completes." IsChecked="{Binding OpenGeneratedFilesInIDE}"
+                <CheckBox x:Name="OpenGeneratedFilesInIDE" Content="Open generated files in the IDE when generation completes." IsChecked="{Binding Path=UserSettings.OpenGeneratedFilesInIDE, Mode=TwoWay}"
                     HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0, 5"/>
-                <CheckBox x:Name="GenerateMultipleFiles" Content="Generate multiple files." IsChecked="{Binding GenerateMultipleFiles}"
+                <CheckBox x:Name="GenerateMultipleFiles" Content="Generate multiple files." IsChecked="{Binding Path=UserSettings.GenerateMultipleFiles, Mode=TwoWay}"
                     HorizontalAlignment="Left" VerticalAlignment="Top" Margin="0, 5"/>
             </StackPanel>
         </StackPanel>
diff --git a/src/Views/ConfigODataEndpoint.xaml b/src/Views/ConfigODataEndpoint.xaml
index 4590586a..abf648a5 100644
--- a/src/Views/ConfigODataEndpoint.xaml
+++ b/src/Views/ConfigODataEndpoint.xaml
@@ -38,7 +38,7 @@
                 Height="20"
                 Margin="0,5,10,5"
                 HorizontalAlignment="Left"
-                Text="{Binding Path=ServiceName, Mode=TwoWay}" />
+                Text="{Binding Path=UserSettings.ServiceName, Mode=TwoWay}" />
             <Button
                 x:Name="OpenConnectedServiceJsonFileButton"
                 Grid.Column="1"
@@ -71,7 +71,7 @@
                 HorizontalAlignment="Stretch"
                 IsEditable="True"
                 ItemsSource="{Binding Path=UserSettings.MruEndpoints}"
-                Text="{Binding Path=Endpoint, Mode=TwoWay, TargetNullValue='Enter your endpoint...'}" />
+                Text="{Binding Path=UserSettings.Endpoint, Mode=TwoWay, TargetNullValue='Enter your endpoint...'}" />
             <Button
                 x:Name="OpenEndpointFileButton"
                 Grid.Column="1"
@@ -91,7 +91,7 @@
             VerticalAlignment="Top"
             Content="Include Custom Http Headers"
             FontWeight="Medium"
-            IsChecked="{Binding IncludeCustomHeaders, Mode=TwoWay}" />
+            IsChecked="{Binding Path=UserSettings.IncludeCustomHeaders, Mode=TwoWay}" />
 
         <StackPanel Margin="20,0,0,0" Visibility="{Binding Path=IsChecked, ElementName=IncludeHttpHeadersElement, Converter={StaticResource BooleanToVisibilityConverter}}">
 
@@ -106,7 +106,7 @@
                 Margin="20,5,10,5"
                 HorizontalAlignment="Left"
                 AcceptsReturn="True"
-                Text="{Binding Path=CustomHttpHeaders, Mode=TwoWay}"
+                Text="{Binding Path=UserSettings.CustomHttpHeaders, Mode=TwoWay}"
                 TextWrapping="Wrap"
                 VerticalScrollBarVisibility="Visible">
                 <TextBox.ToolTip>
@@ -128,7 +128,7 @@
             VerticalAlignment="Top"
             Content="Include WebProxy"
             FontWeight="Medium"
-            IsChecked="{Binding IncludeWebProxy, Mode=TwoWay}" />
+            IsChecked="{Binding Path=UserSettings.IncludeWebProxy, Mode=TwoWay}" />
 
         <StackPanel Margin="20,0,0,0" Visibility="{Binding Path=IsChecked, ElementName=IncludeWebProxyElement, Converter={StaticResource BooleanToVisibilityConverter}}">
 
@@ -143,7 +143,7 @@
                     Width="300"
                     Margin="0,0,0,0"
                     HorizontalAlignment="Left"
-                    Text="{Binding WebProxyHost}"
+                    Text="{Binding Path=UserSettings.WebProxyHost, Mode=TwoWay}"
                     TextWrapping="Wrap" />
             </StackPanel>
             <CheckBox
@@ -153,7 +153,7 @@
                 VerticalAlignment="Top"
                 Content="Include Proxy Network credentials"
                 FontWeight="Medium"
-                IsChecked="{Binding IncludeWebProxyNetworkCredentials, Mode=TwoWay}" />
+                IsChecked="{Binding Path=UserSettings.IncludeWebProxyNetworkCredentials, Mode=TwoWay}" />
             <StackPanel
                 Margin="20,0,0,0"
                 Orientation="Vertical"
@@ -169,7 +169,7 @@
                     Width="300"
                     Margin="0,5,0,0"
                     HorizontalAlignment="Left"
-                    Text="{Binding WebProxyNetworkCredentialsUsername, Mode=TwoWay}"
+                    Text="{Binding Path=UserSettings.WebProxyNetworkCredentialsUsername, Mode=TwoWay}"
                     TextWrapping="Wrap" />
 
                 <TextBlock
@@ -182,7 +182,7 @@
                     Width="300"
                     Margin="0,5,0,0"
                     HorizontalAlignment="Left"
-                    Text="{Binding WebProxyNetworkCredentialsPassword, Mode=TwoWay}"
+                    Text="{Binding Path=UserSettings.WebProxyNetworkCredentialsPassword, Mode=TwoWay}"
                     TextWrapping="Wrap" />
 
                 <TextBlock
@@ -195,7 +195,7 @@
                     Width="300"
                     Margin="0,5,0,0"
                     HorizontalAlignment="Left"
-                    Text="{Binding WebProxyNetworkCredentialsDomain, Mode=TwoWay}"
+                    Text="{Binding Path=UserSettings.WebProxyNetworkCredentialsDomain, Mode=TwoWay}"
                     TextWrapping="Wrap" />
 
             </StackPanel>
diff --git a/src/Views/ConfigODataEndpoint.xaml.cs b/src/Views/ConfigODataEndpoint.xaml.cs
index c7d0182b..d151aa85 100644
--- a/src/Views/ConfigODataEndpoint.xaml.cs
+++ b/src/Views/ConfigODataEndpoint.xaml.cs
@@ -6,7 +6,6 @@
 using Microsoft.OData.ConnectedService.Models;
 using Microsoft.OData.ConnectedService.ViewModels;
 using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using System.IO;
 using System.Windows;
 using System.Windows.Controls;
@@ -20,6 +19,7 @@ namespace Microsoft.OData.ConnectedService.Views
     public partial class ConfigODataEndpoint : UserControl
     {
         internal UserSettings UserSettings { get; set; }
+
         public ConfigODataEndpoint()
         {
             InitializeComponent();
@@ -27,7 +27,10 @@ public ConfigODataEndpoint()
 
         private void UserControl_Loaded(object sender, RoutedEventArgs e)
         {
-            if (Endpoint.Items.Count > 0 && !((ConfigODataEndpointViewModel)this.DataContext).ServiceWizard.Context.IsUpdating)
+            ODataConnectedServiceWizard connectedServiceWizard = GetODataConnectedServiceWizard();
+            UserSettings = connectedServiceWizard.UserSettings;
+
+            if (Endpoint.Items.Count > 0 && !connectedServiceWizard.Context.IsUpdating)
             {
                 Endpoint.SelectedItem = Endpoint.Items[0];
             }
@@ -53,103 +56,95 @@ private void OpenMetadataFileButton_OnClick(object sender, RoutedEventArgs e)
 
         private void OpenConnectedServiceJsonFileButton_Click(object sender, RoutedEventArgs e)
         {
-            var openFileDialog = new Microsoft.Win32.OpenFileDialog
+            var fileDialogTitle = "Open OData Connected Service Config File";
+
+            var openFileDialog = new Win32.OpenFileDialog
             {
                 DefaultExt = ".json",
                 Filter = "JSON File (.json)|*.json",
-                Title = "Open OData Connected Service Config File"
+                Title = fileDialogTitle
             };
 
-            var result = openFileDialog.ShowDialog();
-            if (result == false)
+            if (!(openFileDialog.ShowDialog() == true)) // Result of ShowDialog() call is bool?
+            {
                 return;
+            }
+
             if (!File.Exists(openFileDialog.FileName))
             {
-               MessageBox.Show($"File \"{openFileDialog.FileName}\" does not exists.", string.Format(CultureInfo.InvariantCulture, "Open OData Connected Service json-file"), MessageBoxButton.OK, MessageBoxImage.Warning);
+               MessageBox.Show(
+                   $"File \"{openFileDialog.FileName}\" does not exists.",
+                   string.Format(CultureInfo.InvariantCulture, fileDialogTitle),
+                   MessageBoxButton.OK,
+                   MessageBoxImage.Warning);
                return;
             }
 
             var jsonFileText = File.ReadAllText(openFileDialog.FileName);
             if (string.IsNullOrWhiteSpace(jsonFileText))
             {
-               MessageBox.Show("File have not content.", string.Format(CultureInfo.InvariantCulture, "Open OData Connected Service json-file"), MessageBoxButton.OK, MessageBoxImage.Warning);
+               MessageBox.Show("Config file is empty.",
+                   string.Format(CultureInfo.InvariantCulture, fileDialogTitle),
+                   MessageBoxButton.OK,
+                   MessageBoxImage.Warning);
                return;
             }
-            if (JObject.Parse(jsonFileText) == null)
+
+            ConnectedServiceJsonFileData connectedServiceData;
+
+            try
+            {
+                connectedServiceData = JsonConvert.DeserializeObject<ConnectedServiceJsonFileData>(jsonFileText);
+            }
+            catch (JsonException ex)
             {
-                MessageBox.Show("Can't convert file content to JObject.", string.Format(CultureInfo.InvariantCulture, "Open OData Connected Service json-file"), MessageBoxButton.OK, MessageBoxImage.Warning);
+                System.Diagnostics.Debug.Assert(ex != null);
+                MessageBox.Show(
+                    "Contents of the config file could not be deserialized.",
+                    string.Format(CultureInfo.InvariantCulture, fileDialogTitle),
+                    MessageBoxButton.OK,
+                    MessageBoxImage.Warning);
                 return;
             }
-            var microsoftConnectedServiceData = JsonConvert.DeserializeObject<ConnectedServiceJsonFileData>(jsonFileText);
-            if (microsoftConnectedServiceData != null)
+
+            // connectedServiceData not expected to be null at this point
+            if (connectedServiceData.ExtendedData != null)
             {
-                this.UserSettings = new UserSettings();
-                this.UserSettings.Endpoint = microsoftConnectedServiceData.ExtendedData?.Endpoint ?? this.UserSettings.Endpoint;
-                this.UserSettings.ServiceName = microsoftConnectedServiceData.ExtendedData?.ServiceName ?? this.UserSettings.ServiceName;
-                this.UserSettings.GeneratedFileNamePrefix = microsoftConnectedServiceData.ExtendedData?.GeneratedFileNamePrefix ?? this.UserSettings.GeneratedFileNamePrefix;
-                this.UserSettings.OpenGeneratedFilesInIDE = microsoftConnectedServiceData.ExtendedData?.OpenGeneratedFilesInIDE ?? this.UserSettings.OpenGeneratedFilesInIDE;
-                this.UserSettings.MakeTypesInternal = microsoftConnectedServiceData.ExtendedData?.MakeTypesInternal ?? this.UserSettings.MakeTypesInternal;
-                this.UserSettings.NamespacePrefix = microsoftConnectedServiceData.ExtendedData?.NamespacePrefix ?? this.UserSettings.NamespacePrefix;
-                this.UserSettings.UseDataServiceCollection = microsoftConnectedServiceData.ExtendedData?.UseDataServiceCollection ?? this.UserSettings.UseDataServiceCollection;
-                this.UserSettings.UseNamespacePrefix = microsoftConnectedServiceData.ExtendedData?.UseNamespacePrefix ?? this.UserSettings.UseNamespacePrefix;
-                this.UserSettings.IncludeT4File = microsoftConnectedServiceData.ExtendedData?.IncludeT4File ?? this.UserSettings.IncludeT4File;
-                this.UserSettings.IgnoreUnexpectedElementsAndAttributes = microsoftConnectedServiceData.ExtendedData?.IgnoreUnexpectedElementsAndAttributes ?? this.UserSettings.IgnoreUnexpectedElementsAndAttributes;
-                this.UserSettings.GenerateMultipleFiles = microsoftConnectedServiceData.ExtendedData?.GenerateMultipleFiles ?? this.UserSettings.GenerateMultipleFiles;
-                this.UserSettings.EnableNamingAlias = microsoftConnectedServiceData.ExtendedData?.EnableNamingAlias ?? this.UserSettings.EnableNamingAlias;
-                this.UserSettings.CustomHttpHeaders = microsoftConnectedServiceData.ExtendedData?.CustomHttpHeaders ?? this.UserSettings.CustomHttpHeaders;
-                this.UserSettings.IncludeCustomHeaders = microsoftConnectedServiceData.ExtendedData?.IncludeCustomHeaders ?? this.UserSettings.IncludeCustomHeaders;
-                this.UserSettings.ExcludedOperationImports = microsoftConnectedServiceData.ExtendedData?.ExcludedOperationImports ?? new List<string>();
-                this.UserSettings.ExcludedBoundOperations = microsoftConnectedServiceData.ExtendedData?.ExcludedBoundOperations ?? new List<string>();
-                this.UserSettings.ExcludedSchemaTypes = microsoftConnectedServiceData.ExtendedData?.ExcludedSchemaTypes ?? new List<string>();
-                this.UserSettings.WebProxyHost = microsoftConnectedServiceData.ExtendedData?.WebProxyHost ?? this.UserSettings.WebProxyHost;
-                this.UserSettings.IncludeWebProxy = microsoftConnectedServiceData.ExtendedData?.IncludeWebProxy ?? this.UserSettings.IncludeWebProxy;
-                this.UserSettings.IncludeWebProxyNetworkCredentials = microsoftConnectedServiceData.ExtendedData?.IncludeWebProxyNetworkCredentials ?? this.UserSettings.IncludeWebProxyNetworkCredentials;
-                this.UserSettings.WebProxyNetworkCredentialsDomain = microsoftConnectedServiceData.ExtendedData?.WebProxyNetworkCredentialsDomain ?? this.UserSettings.WebProxyNetworkCredentialsDomain;
-                this.UserSettings.WebProxyNetworkCredentialsPassword = microsoftConnectedServiceData.ExtendedData?.WebProxyNetworkCredentialsPassword ?? this.UserSettings.WebProxyNetworkCredentialsPassword;
-                this.UserSettings.WebProxyNetworkCredentialsUsername = microsoftConnectedServiceData.ExtendedData?.WebProxyNetworkCredentialsUsername ?? this.UserSettings.WebProxyNetworkCredentialsUsername;
-                ODataConnectedServiceWizard ServiceWizard = ((ConfigODataEndpointViewModel)this.DataContext).ServiceWizard;
-                this.UserSettings.MruEndpoints = UserSettings.Load(ServiceWizard.Context.Logger)?.MruEndpoints;
-
-                ServiceWizard.ConfigODataEndpointViewModel.UserSettings = this.UserSettings;
-                ServiceWizard.ConfigODataEndpointViewModel.LoadFromUserSettings();
-
-                ServiceWizard.AdvancedSettingsViewModel.UserSettings = this.UserSettings;
-                ServiceWizard.AdvancedSettingsViewModel.LoadFromUserSettings();
-
-                ServiceWizard.OperationImportsViewModel.UserSettings = this.UserSettings;
-
-                // get Operation Imports and bound operations from metadata for excluding ExcludedOperationImports and ExcludedBoundOperations
-                try
-                {
-                    ServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath = ServiceWizard.ConfigODataEndpointViewModel.GetMetadata(out var version);
-                    ServiceWizard.ConfigODataEndpointViewModel.EdmxVersion = version;
-                    if (version == Constants.EdmxVersion4)
-                    {
-                        Edm.IEdmModel model = EdmHelper.GetEdmModelFromFile(ServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath);
-
-                        IEnumerable<Edm.IEdmSchemaType> entityTypes = EdmHelper.GetSchemaTypes(model);
-                        IDictionary<Edm.IEdmType, List<Edm.IEdmOperation>> boundOperations = EdmHelper.GetBoundOperations(model);
-                        ServiceWizard.SchemaTypesViewModel.LoadSchemaTypes(entityTypes, boundOperations);
-                        ServiceWizard.ProcessedEndpointForSchemaTypes = this.UserSettings.Endpoint;
-                        ServiceWizard.SchemaTypesViewModel.LoadFromUserSettings();
-
-                        IEnumerable<Edm.IEdmOperationImport> operations = EdmHelper.GetOperationImports(model);
-                        ServiceWizard.OperationImportsViewModel.LoadOperationImports(operations, new HashSet<string>(), new Dictionary<string, SchemaTypeModel>());
-                        ServiceWizard.ProcessedEndpointForOperationImports = this.UserSettings.Endpoint;
-                        ServiceWizard.OperationImportsViewModel.LoadFromUserSettings();
-
-                        //IDictionary<Edm.IEdmType, List<Edm.IEdmOperation>> allBoundOperations = EdmHelper.GetBoundOperations(model);
-                        //ServiceWizard.BoundOperationsViewModel.LoadBoundOperations(allBoundOperations,
-                        //    new HashSet<string>(), new Dictionary<string, SchemaTypeModel>());
-                        //ServiceWizard.ProcessedEndpointForBoundOperations = this.UserSettings.Endpoint;
-                        //ServiceWizard.BoundOperationsViewModel.LoadFromUserSettings();
-                    }
-                }
-                catch
+                this.UserSettings.CopyPropertiesFrom(connectedServiceData.ExtendedData);
+            }
+
+            ODataConnectedServiceWizard connectedServiceWizard = GetODataConnectedServiceWizard();
+
+            // get Operation Imports and bound operations from metadata for excluding ExcludedOperationImports and ExcludedBoundOperations
+            try
+            {
+                connectedServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath = connectedServiceWizard.ConfigODataEndpointViewModel.GetMetadata(out var version);
+                connectedServiceWizard.ConfigODataEndpointViewModel.EdmxVersion = version;
+                if (version == Constants.EdmxVersion4)
                 {
-                    // ignored
+                    Edm.IEdmModel model = EdmHelper.GetEdmModelFromFile(connectedServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath);
+
+                    IEnumerable<Edm.IEdmSchemaType> entityTypes = EdmHelper.GetSchemaTypes(model);
+                    IDictionary<Edm.IEdmType, List<Edm.IEdmOperation>> boundOperations = EdmHelper.GetBoundOperations(model);
+                    connectedServiceWizard.SchemaTypesViewModel.LoadSchemaTypes(entityTypes, boundOperations);
+                    connectedServiceWizard.ProcessedEndpointForSchemaTypes = this.UserSettings.Endpoint;
+                    connectedServiceWizard.SchemaTypesViewModel.LoadFromUserSettings();
+
+                    IEnumerable<Edm.IEdmOperationImport> operations = EdmHelper.GetOperationImports(model);
+                    connectedServiceWizard.OperationImportsViewModel.LoadOperationImports(operations, new HashSet<string>(), new Dictionary<string, SchemaTypeModel>());
+                    connectedServiceWizard.ProcessedEndpointForOperationImports = this.UserSettings.Endpoint;
+                    connectedServiceWizard.OperationImportsViewModel.LoadFromUserSettings();
                 }
             }
+            catch
+            {
+                // ignored
+            }
+        }
+
+        private ODataConnectedServiceWizard GetODataConnectedServiceWizard()
+        {
+            return (ODataConnectedServiceWizard)((ConfigODataEndpointViewModel)this.DataContext).Wizard;
         }
     }
 }
diff --git a/src/source.extension.vsixmanifest b/src/source.extension.vsixmanifest
index 2f385003..8f71db3f 100644
--- a/src/source.extension.vsixmanifest
+++ b/src/source.extension.vsixmanifest
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
     <Metadata>
-        <Identity Id="ODataConnectedService.e30335d6-f9c7-4d08-b66a-f011f3f18477" Version="0.11.2" Language="en-US" Publisher="Microsoft" />
+        <Identity Id="ODataConnectedService.e30335d6-f9c7-4d08-b66a-f011f3f18477" Version="0.11.1" Language="en-US" Publisher="Microsoft" />
         <Author>Microsoft</Author>
         <DisplayName>OData Connected Service</DisplayName>
         <Description xml:space="preserve">OData Connected Service for V1-V4</Description>
diff --git a/test/ODataConnectedService.Tests/Common/ExtensionMethodsTests.cs b/test/ODataConnectedService.Tests/Common/ExtensionMethodsTests.cs
new file mode 100644
index 00000000..b106bade
--- /dev/null
+++ b/test/ODataConnectedService.Tests/Common/ExtensionMethodsTests.cs
@@ -0,0 +1,149 @@
+//-----------------------------------------------------------------------------------
+// <copyright file="ExtensionMethodsTests.cs" company=".NET Foundation">
+//      Copyright (c) .NET Foundation and Contributors. All rights reserved.
+//      See License.txt in the project root for license information.
+// </copyright>
+//-----------------------------------------------------------------------------------
+
+using System;
+using System.Collections.Generic;
+using Microsoft.OData.ConnectedService.Common;
+using Microsoft.OData.ConnectedService.Models;
+using Xunit;
+
+namespace ODataConnectedService.Tests
+{
+    public class ExtensionMethodsTests
+    {
+        private static UserSettings CreateUserSettings()
+        {
+            var userSettings = new UserSettings(configName: "TestSettings");
+
+            userSettings.CustomHttpHeaders = "Key:Test";
+            userSettings.EnableNamingAlias = true;
+            userSettings.Endpoint = "http://test";
+            userSettings.ExcludedBoundOperations = new List<string> { "TestBoundOperation" };
+            userSettings.ExcludedOperationImports = new List<string> { "TestOperationImport" };
+            userSettings.ExcludedSchemaTypes = new List<string> { "TestSchemaType" };
+            userSettings.GeneratedFileNamePrefix = "Test";
+            userSettings.GenerateMultipleFiles = true;
+            userSettings.IgnoreUnexpectedElementsAndAttributes = true;
+            userSettings.IncludeCustomHeaders = true;
+            userSettings.IncludeT4File = true;
+            userSettings.IncludeWebProxy = true;
+            userSettings.IncludeWebProxyNetworkCredentials = true;
+            userSettings.MakeTypesInternal = true;
+            userSettings.NamespacePrefix = "Test";
+            userSettings.OpenGeneratedFilesInIDE = true;
+            userSettings.ServiceName = "Test";
+            userSettings.UseDataServiceCollection = true;
+            userSettings.UseNamespacePrefix = true;
+            userSettings.WebProxyHost = "Test";
+            userSettings.WebProxyNetworkCredentialsDomain = "Test";
+            userSettings.WebProxyNetworkCredentialsPassword = "Test";
+            userSettings.WebProxyNetworkCredentialsUsername = "Test";
+            userSettings.AddMruEndpoint("http://test");
+
+            return userSettings;
+        }
+
+        private static ServiceConfigurationV4 CreateServiceConfiguration()
+        {
+            var serviceConfig = new ServiceConfigurationV4();
+            serviceConfig.CustomHttpHeaders = "Key:Test";
+            serviceConfig.EdmxVersion = new Version(4, 0, 0, 0);
+            serviceConfig.EnableNamingAlias = true;
+            serviceConfig.Endpoint = "http://test";
+            serviceConfig.ExcludedBoundOperations = new List<string> { "TestBoundOperation" };
+            serviceConfig.ExcludedOperationImports = new List<string> { "TestOperationImport" };
+            serviceConfig.ExcludedSchemaTypes = new List<string> { "TestSchemaType" };
+            serviceConfig.GeneratedFileNamePrefix = "Test";
+            serviceConfig.GenerateMultipleFiles = true;
+            serviceConfig.IgnoreUnexpectedElementsAndAttributes = true;
+            serviceConfig.IncludeCustomHeaders = true;
+            serviceConfig.IncludeT4File = true;
+            serviceConfig.IncludeWebProxy = true;
+            serviceConfig.IncludeWebProxyNetworkCredentials = true;
+            serviceConfig.MakeTypesInternal = true;
+            serviceConfig.NamespacePrefix = "Test";
+            serviceConfig.OpenGeneratedFilesInIDE = true;
+            serviceConfig.ServiceName = "Test";
+            serviceConfig.UseDataServiceCollection = true;
+            serviceConfig.UseNamespacePrefix = true;
+            serviceConfig.WebProxyHost = "Test";
+            serviceConfig.WebProxyNetworkCredentialsDomain = "Test";
+            serviceConfig.WebProxyNetworkCredentialsPassword = "Test";
+            serviceConfig.WebProxyNetworkCredentialsUsername = "Test";
+
+            return serviceConfig;
+        }
+
+        [Fact]
+        public void TestCopyPropertiesFromUserSettingsToServiceConfiguration()
+        {
+            var userSettings = CreateUserSettings();
+
+            var serviceConfig = new ServiceConfigurationV4();
+
+            serviceConfig.CopyPropertiesFrom(userSettings);
+
+            Assert.Equal("Key:Test", serviceConfig.CustomHttpHeaders);
+            Assert.True(serviceConfig.EnableNamingAlias);
+            Assert.Equal("http://test", serviceConfig.Endpoint);
+            Assert.Single(serviceConfig.ExcludedBoundOperations, "TestBoundOperation");
+            Assert.Single(serviceConfig.ExcludedOperationImports, "TestOperationImport");
+            Assert.Single(serviceConfig.ExcludedSchemaTypes, "TestSchemaType");
+            Assert.Equal("Test", serviceConfig.GeneratedFileNamePrefix);
+            Assert.True(serviceConfig.GenerateMultipleFiles);
+            Assert.True(serviceConfig.IgnoreUnexpectedElementsAndAttributes);
+            Assert.True(serviceConfig.IncludeCustomHeaders);
+            Assert.True(serviceConfig.IncludeT4File);
+            Assert.True(serviceConfig.IncludeWebProxy);
+            Assert.True(serviceConfig.IncludeWebProxyNetworkCredentials);
+            Assert.True(serviceConfig.MakeTypesInternal);
+            Assert.Equal("Test", serviceConfig.NamespacePrefix);
+            Assert.True(serviceConfig.OpenGeneratedFilesInIDE);
+            Assert.Equal("Test", serviceConfig.ServiceName);
+            Assert.True(serviceConfig.UseDataServiceCollection);
+            Assert.True(serviceConfig.UseNamespacePrefix);
+            Assert.Equal("Test", serviceConfig.WebProxyHost);
+            Assert.Equal("Test", serviceConfig.WebProxyNetworkCredentialsDomain);
+            Assert.Equal("Test", serviceConfig.WebProxyNetworkCredentialsPassword);
+            Assert.Equal("Test", serviceConfig.WebProxyNetworkCredentialsUsername);
+        }
+
+        [Fact]
+        public void TestCopyPropertiesFromServiceConfigurationToUserSettings()
+        {
+            var serviceConfig = CreateServiceConfiguration();
+
+            var userSettings = new UserSettings(configName: "TestUserSettings");
+
+            userSettings.CopyPropertiesFrom(serviceConfig);
+
+            Assert.Equal("Key:Test", userSettings.CustomHttpHeaders);
+            Assert.True(userSettings.EnableNamingAlias);
+            Assert.Equal("http://test", userSettings.Endpoint);
+            Assert.Single(userSettings.ExcludedBoundOperations, "TestBoundOperation");
+            Assert.Single(userSettings.ExcludedOperationImports, "TestOperationImport");
+            Assert.Single(userSettings.ExcludedSchemaTypes, "TestSchemaType");
+            Assert.Equal("Test", userSettings.GeneratedFileNamePrefix);
+            Assert.True(userSettings.GenerateMultipleFiles);
+            Assert.True(userSettings.IgnoreUnexpectedElementsAndAttributes);
+            Assert.True(userSettings.IncludeCustomHeaders);
+            Assert.True(userSettings.IncludeT4File);
+            Assert.True(userSettings.IncludeWebProxy);
+            Assert.True(userSettings.IncludeWebProxyNetworkCredentials);
+            Assert.True(userSettings.MakeTypesInternal);
+            Assert.Equal("Test", userSettings.NamespacePrefix);
+            Assert.True(userSettings.OpenGeneratedFilesInIDE);
+            Assert.Equal("Test", userSettings.ServiceName);
+            Assert.True(userSettings.UseDataServiceCollection);
+            Assert.True(userSettings.UseNamespacePrefix);
+            Assert.Equal("Test", userSettings.WebProxyHost);
+            Assert.Equal("Test", userSettings.WebProxyNetworkCredentialsDomain);
+            Assert.Equal("Test", userSettings.WebProxyNetworkCredentialsPassword);
+            Assert.Equal("Test", userSettings.WebProxyNetworkCredentialsUsername);
+        }
+    }
+}
diff --git a/test/ODataConnectedService.Tests/ODataConnectedService.Tests.csproj b/test/ODataConnectedService.Tests/ODataConnectedService.Tests.csproj
index e7b615c0..9408413b 100644
--- a/test/ODataConnectedService.Tests/ODataConnectedService.Tests.csproj
+++ b/test/ODataConnectedService.Tests/ODataConnectedService.Tests.csproj
@@ -63,6 +63,7 @@
     <Reference Include="System.Core" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Common\ExtensionMethodsTests.cs" />
     <Compile Include="Common\EdmHelperTests.cs" />
     <Compile Include="Converters\BoolToVisibilityConverterTests.cs" />
     <Compile Include="Converters\SchemaTypeModelToVisibilityConverterTests.cs" />
diff --git a/test/ODataConnectedService.Tests/ODataConnectedServiceWizardTests.cs b/test/ODataConnectedService.Tests/ODataConnectedServiceWizardTests.cs
index fb69143b..a6107b94 100644
--- a/test/ODataConnectedService.Tests/ODataConnectedServiceWizardTests.cs
+++ b/test/ODataConnectedService.Tests/ODataConnectedServiceWizardTests.cs
@@ -25,22 +25,25 @@
 namespace ODataConnectedService.Tests
 {
 
-    public class ODataConnectedServiceWizardTests: IDisposable
+    public sealed class ODataConnectedServiceWizardTests: IDisposable
     {
-
-        UserSettings initialSettings = UserSettings.Load(null);
+        readonly UserSettings initialSettings;
         readonly string MetadataPath = Path.GetFullPath("TestMetadataCsdl.xml");
         readonly string MetadataPathV3 = Path.GetFullPath("TestMetadataCsdlV3.xml");
         readonly string MetadataPathSimple = Path.GetFullPath("TestMetadataCsdlSimple.xml");
 
         public ODataConnectedServiceWizardTests()
         {
-            ResetUserSettings();
+            initialSettings = new UserSettings();
+            initialSettings.Load();
+            // Reset user settings
+            new UserSettings().Save();
         }
 
+        // Will be executed after every test to restore initial settings
         public void Dispose()
         {
-            RestoreUserSettings();
+            initialSettings.Save();
         }
 
         private ServiceConfigurationV4 GetTestConfig()
@@ -91,29 +94,18 @@ private ServiceConfigurationV4 GetTestConfig()
             };
         }
 
-        private void ResetUserSettings()
-        {
-            var settings = new UserSettings();
-            settings.Save();
-        }
-
-        private void RestoreUserSettings()
-        {
-            initialSettings.Save();
-        }
-
         [Fact]
         public void TestLoadUserSettingsWhenWizardIsCreated()
         {
             var settings = new UserSettings();
-            settings.ServiceName = "Some Service";
-            settings.MruEndpoints.Add("Endpoint");
+            settings.ServiceName = "OData Service";
+            settings.AddMruEndpoint("Endpoint");
             settings.Save();
 
             var context = new TestConnectedServiceProviderContext();
             using (var wizard = new ODataConnectedServiceWizard(context))
             {
-                Assert.Equal("Some Service", wizard.UserSettings.ServiceName);
+                Assert.Equal("OData Service", wizard.UserSettings.ServiceName);
                 Assert.Contains("Endpoint", wizard.UserSettings.MruEndpoints);
             }
         }
@@ -128,20 +120,20 @@ public void TestConstructor_ShouldUseDefaultSettingsWhenNotUpdating()
             {
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
                 endpointPage.OnPageEnteringAsync(new WizardEnteringArgs(null)).Wait();
-                Assert.Equal(Constants.DefaultServiceName, endpointPage.ServiceName);
-                Assert.Null(endpointPage.Endpoint);
+                Assert.Equal(Constants.DefaultServiceName, endpointPage.UserSettings.ServiceName);
+                Assert.Null(endpointPage.UserSettings.Endpoint);
                 Assert.Null(endpointPage.EdmxVersion);
-                Assert.False(endpointPage.IncludeCustomHeaders);
-                Assert.Null(endpointPage.CustomHttpHeaders);
-                Assert.False(endpointPage.IncludeWebProxy);
-                Assert.Null(endpointPage.WebProxyHost);
-                Assert.False(endpointPage.IncludeWebProxyNetworkCredentials);
-                Assert.Null(endpointPage.WebProxyNetworkCredentialsDomain);
-                Assert.Null(endpointPage.WebProxyNetworkCredentialsUsername);
-                Assert.Null(endpointPage.WebProxyNetworkCredentialsPassword);
+                Assert.False(endpointPage.UserSettings.IncludeCustomHeaders);
+                Assert.Null(endpointPage.UserSettings.CustomHttpHeaders);
+                Assert.False(endpointPage.UserSettings.IncludeWebProxy);
+                Assert.Null(endpointPage.UserSettings.WebProxyHost);
+                Assert.False(endpointPage.UserSettings.IncludeWebProxyNetworkCredentials);
+                Assert.Null(endpointPage.UserSettings.WebProxyNetworkCredentialsDomain);
+                Assert.Null(endpointPage.UserSettings.WebProxyNetworkCredentialsUsername);
+                Assert.Null(endpointPage.UserSettings.WebProxyNetworkCredentialsPassword);
 
                 var operationsPage = wizard.OperationImportsViewModel;
-                endpointPage.Endpoint = MetadataPath;
+                endpointPage.UserSettings.Endpoint = MetadataPath;
                 endpointPage.MetadataTempPath = MetadataPath;
                 endpointPage.EdmxVersion = Constants.EdmxVersion4;
                 operationsPage.OnPageEnteringAsync(new WizardEnteringArgs(endpointPage)).Wait();
@@ -256,16 +248,16 @@ public void TestConstructor_ShouldUseDefaultSettingsWhenNotUpdating()
 
                 var advancedPage = wizard.AdvancedSettingsViewModel;
                 advancedPage.OnPageEnteringAsync(new WizardEnteringArgs(typesPage)).Wait();
-                Assert.Equal(Constants.DefaultReferenceFileName, advancedPage.GeneratedFileNamePrefix);
-                Assert.False(advancedPage.UseNamespacePrefix);
-                Assert.Equal(Constants.DefaultReferenceFileName, advancedPage.NamespacePrefix);
-                Assert.False(advancedPage.UseDataServiceCollection);
-                Assert.False(advancedPage.EnableNamingAlias);
-                Assert.False(advancedPage.OpenGeneratedFilesInIDE);
-                Assert.False(advancedPage.IncludeT4File);
-                Assert.False(advancedPage.GenerateMultipleFiles);
-                Assert.False(advancedPage.IgnoreUnexpectedElementsAndAttributes);
-                Assert.False(advancedPage.MakeTypesInternal);
+                Assert.Equal(Constants.DefaultReferenceFileName, advancedPage.UserSettings.GeneratedFileNamePrefix);
+                Assert.False(advancedPage.UserSettings.UseNamespacePrefix);
+                Assert.Equal(Constants.DefaultReferenceFileName, advancedPage.UserSettings.NamespacePrefix);
+                Assert.True(advancedPage.UserSettings.UseDataServiceCollection);
+                Assert.True(advancedPage.UserSettings.EnableNamingAlias);
+                Assert.False(advancedPage.UserSettings.OpenGeneratedFilesInIDE);
+                Assert.False(advancedPage.UserSettings.IncludeT4File);
+                Assert.False(advancedPage.UserSettings.GenerateMultipleFiles);
+                Assert.True(advancedPage.UserSettings.IgnoreUnexpectedElementsAndAttributes);
+                Assert.False(advancedPage.UserSettings.MakeTypesInternal);
             }
         }
 
@@ -281,17 +273,17 @@ public void TestConstructor_LoadsSavedConfigWhenUpdating()
 
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
                 endpointPage.OnPageEnteringAsync(new WizardEnteringArgs(null)).Wait();
-                Assert.Equal("https://service/$metadata", endpointPage.Endpoint);
-                Assert.Equal("MyService", endpointPage.ServiceName);
-                Assert.True(endpointPage.IncludeCustomHeaders);
-                Assert.Equal("Key1:Val1\nKey2:Val2", endpointPage.CustomHttpHeaders);
-                Assert.True(endpointPage.IncludeWebProxy);
-                Assert.Equal("http://localhost:8080", endpointPage.WebProxyHost);
-                Assert.True(endpointPage.IncludeWebProxyNetworkCredentials);
-                Assert.Equal("domain", endpointPage.WebProxyNetworkCredentialsDomain);
+                Assert.Equal("https://service/$metadata", endpointPage.UserSettings.Endpoint);
+                Assert.Equal("MyService", endpointPage.UserSettings.ServiceName);
+                Assert.True(endpointPage.UserSettings.IncludeCustomHeaders);
+                Assert.Equal("Key1:Val1\nKey2:Val2", endpointPage.UserSettings.CustomHttpHeaders);
+                Assert.True(endpointPage.UserSettings.IncludeWebProxy);
+                Assert.Equal("http://localhost:8080", endpointPage.UserSettings.WebProxyHost);
+                Assert.True(endpointPage.UserSettings.IncludeWebProxyNetworkCredentials);
+                Assert.Equal("domain", endpointPage.UserSettings.WebProxyNetworkCredentialsDomain);
                 // username and password are not restored from the config
-                Assert.Null(endpointPage.WebProxyNetworkCredentialsUsername);
-                Assert.Null(endpointPage.WebProxyNetworkCredentialsPassword);
+                Assert.Equal("username", endpointPage.UserSettings.WebProxyNetworkCredentialsUsername);
+                Assert.Equal("password", endpointPage.UserSettings.WebProxyNetworkCredentialsPassword);
 
                 var operationsPage = wizard.OperationImportsViewModel;
                 endpointPage.MetadataTempPath = MetadataPath;
@@ -418,16 +410,16 @@ public void TestConstructor_LoadsSavedConfigWhenUpdating()
 
                 var advancedPage = wizard.AdvancedSettingsViewModel;
                 advancedPage.OnPageEnteringAsync(new WizardEnteringArgs(typesPage)).Wait();
-                Assert.Equal("GeneratedCode", advancedPage.GeneratedFileNamePrefix);
-                Assert.True(advancedPage.UseNamespacePrefix);
-                Assert.Equal("Namespace", advancedPage.NamespacePrefix);
-                Assert.True(advancedPage.UseDataServiceCollection);
-                Assert.True(advancedPage.EnableNamingAlias);
-                Assert.True(advancedPage.OpenGeneratedFilesInIDE);
-                Assert.True(advancedPage.IncludeT4File);
-                Assert.True(advancedPage.GenerateMultipleFiles);
-                Assert.True(advancedPage.IgnoreUnexpectedElementsAndAttributes);
-                Assert.True(advancedPage.MakeTypesInternal);
+                Assert.Equal("GeneratedCode", advancedPage.UserSettings.GeneratedFileNamePrefix);
+                Assert.True(advancedPage.UserSettings.UseNamespacePrefix);
+                Assert.Equal("Namespace", advancedPage.UserSettings.NamespacePrefix);
+                Assert.True(advancedPage.UserSettings.UseDataServiceCollection);
+                Assert.True(advancedPage.UserSettings.EnableNamingAlias);
+                Assert.True(advancedPage.UserSettings.OpenGeneratedFilesInIDE);
+                Assert.True(advancedPage.UserSettings.IncludeT4File);
+                Assert.True(advancedPage.UserSettings.GenerateMultipleFiles);
+                Assert.True(advancedPage.UserSettings.IgnoreUnexpectedElementsAndAttributes);
+                Assert.True(advancedPage.UserSettings.MakeTypesInternal);
             }
         }
 
@@ -468,17 +460,17 @@ public void TestGetFinishedServiceInstanceAsync_SavesUserSettingsAndReturnsServi
             using(var wizard = new ODataConnectedServiceWizard(context))
             {
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
-                endpointPage.ServiceName = "TestService";
-                endpointPage.Endpoint = MetadataPath;
+                endpointPage.UserSettings.ServiceName = "TestService";
+                endpointPage.UserSettings.Endpoint = MetadataPath;
                 endpointPage.EdmxVersion = Constants.EdmxVersion4;
-                endpointPage.IncludeCustomHeaders = true;
-                endpointPage.CustomHttpHeaders = "Key:val";
-                endpointPage.IncludeWebProxy = true;
-                endpointPage.WebProxyHost = "http://localhost:8080";
-                endpointPage.IncludeWebProxyNetworkCredentials = true;
-                endpointPage.WebProxyNetworkCredentialsDomain = "domain";
-                endpointPage.WebProxyNetworkCredentialsUsername = "user";
-                endpointPage.WebProxyNetworkCredentialsPassword = "pass";
+                endpointPage.UserSettings.IncludeCustomHeaders = true;
+                endpointPage.UserSettings.CustomHttpHeaders = "Key:val";
+                endpointPage.UserSettings.IncludeWebProxy = true;
+                endpointPage.UserSettings.WebProxyHost = "http://localhost:8080";
+                endpointPage.UserSettings.IncludeWebProxyNetworkCredentials = true;
+                endpointPage.UserSettings.WebProxyNetworkCredentialsDomain = "domain";
+                endpointPage.UserSettings.WebProxyNetworkCredentialsUsername = "user";
+                endpointPage.UserSettings.WebProxyNetworkCredentialsPassword = "pass";
 
                 var operationsPage = wizard.OperationImportsViewModel;
                 endpointPage.OnPageLeavingAsync(new WizardLeavingArgs(operationsPage)).Wait();
@@ -521,15 +513,15 @@ public void TestGetFinishedServiceInstanceAsync_SavesUserSettingsAndReturnsServi
                 };
 
                 var advancedPage = wizard.AdvancedSettingsViewModel;
-                advancedPage.GeneratedFileNamePrefix = "GeneratedFile";
-                advancedPage.UseNamespacePrefix = true;
-                advancedPage.NamespacePrefix = "TestNamespace";
-                advancedPage.UseDataServiceCollection = true;
-                advancedPage.EnableNamingAlias = true;
-                advancedPage.MakeTypesInternal = true;
-                advancedPage.IncludeT4File = true;
-                advancedPage.GenerateMultipleFiles = true;
-                advancedPage.OpenGeneratedFilesInIDE = true;
+                advancedPage.UserSettings.GeneratedFileNamePrefix = "GeneratedFile";
+                advancedPage.UserSettings.UseNamespacePrefix = true;
+                advancedPage.UserSettings.NamespacePrefix = "TestNamespace";
+                advancedPage.UserSettings.UseDataServiceCollection = true;
+                advancedPage.UserSettings.EnableNamingAlias = true;
+                advancedPage.UserSettings.MakeTypesInternal = true;
+                advancedPage.UserSettings.IncludeT4File = true;
+                advancedPage.UserSettings.GenerateMultipleFiles = true;
+                advancedPage.UserSettings.OpenGeneratedFilesInIDE = true;
 
                 operationsPage.OnPageLeavingAsync(new WizardLeavingArgs(typesPage)).Wait();
                 typesPage.OnPageLeavingAsync(new WizardLeavingArgs(advancedPage)).Wait();
@@ -538,20 +530,22 @@ public void TestGetFinishedServiceInstanceAsync_SavesUserSettingsAndReturnsServi
                 var config = serviceInstance.ServiceConfig as ServiceConfigurationV4;
 
                 // saved user settings
-                var settings = UserSettings.Load(null);
+                var settings = new UserSettings();
+                settings.Load();
                 Assert.Equal("TestService", settings.ServiceName);
                 Assert.Equal(MetadataPath, settings.Endpoint);
                 // moves endpoint to top of mru list
                 Assert.Equal(MetadataPath, settings.MruEndpoints.First());
                 Assert.Equal(1, settings.MruEndpoints.Count(e => e == MetadataPath));
                 Assert.True(settings.IncludeCustomHeaders);
-                Assert.Equal("Key:val", settings.CustomHttpHeaders);
+                Assert.Null(settings.CustomHttpHeaders); // Custom HTTP headers may contain sensitive details like auth tokens
                 Assert.True(settings.IncludeWebProxy);
                 Assert.Equal("http://localhost:8080", settings.WebProxyHost);
                 Assert.True(settings.IncludeWebProxyNetworkCredentials);
                 Assert.Equal("domain", settings.WebProxyNetworkCredentialsDomain);
-                Assert.Equal("user", settings.WebProxyNetworkCredentialsUsername);
-                Assert.Equal("pass", settings.WebProxyNetworkCredentialsPassword);
+                // We don't persist web proxy network credentials
+                Assert.Null(settings.WebProxyNetworkCredentialsUsername);
+                Assert.Null(settings.WebProxyNetworkCredentialsPassword);
                 settings.ExcludedOperationImports.ShouldBeEquivalentTo(new List<string>() { "GetNearestAirport", "ResetDataSource" });
                 settings.ExcludedBoundOperations.ShouldBeEquivalentTo(new List<string>()
                 {
@@ -636,8 +630,8 @@ public void GetFinishedServiceInstanceAsync_WhenUpdating_ShouldUseSavedConfigWhe
                 Assert.Equal("http://localhost:8080", config.WebProxyHost);
                 Assert.True(config.IncludeWebProxyNetworkCredentials);
                 Assert.Equal("domain", config.WebProxyNetworkCredentialsDomain);
-                Assert.Null(config.WebProxyNetworkCredentialsUsername);
-                Assert.Null(config.WebProxyNetworkCredentialsPassword);
+                Assert.Equal("username", config.WebProxyNetworkCredentialsUsername);
+                Assert.Equal("password", config.WebProxyNetworkCredentialsPassword);
                 config.ExcludedOperationImports.ShouldBeEquivalentTo(new List<string>() { "GetPersonWithMostFriends", "ResetDataSource" });
                 config.ExcludedBoundOperations.ShouldBeEquivalentTo(new List<string>()
                 {
@@ -673,7 +667,7 @@ public void ShouldPreserveState_WhenMovingBetweenPagesAndBack()
             {
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
                 endpointPage.OnPageEnteringAsync(null).Wait();
-                endpointPage.Endpoint = MetadataPath;
+                endpointPage.UserSettings.Endpoint = MetadataPath;
                 endpointPage.OnPageLeavingAsync(null).Wait();
 
                 var typesPage = wizard.SchemaTypesViewModel;
@@ -709,26 +703,26 @@ public void ShouldPreserveState_WhenMovingBetweenPagesAndBack()
 
                 var advancedPage = wizard.AdvancedSettingsViewModel;
                 advancedPage.OnPageEnteringAsync(null).Wait();
-                advancedPage.UseDataServiceCollection = true;
-                advancedPage.MakeTypesInternal = true;
-                advancedPage.UseNamespacePrefix = true;
+                advancedPage.UserSettings.UseDataServiceCollection = true;
+                advancedPage.UserSettings.MakeTypesInternal = true;
+                advancedPage.UserSettings.UseNamespacePrefix = true;
                 advancedPage.OnPageLeavingAsync(null).Wait();
 
                 endpointPage.OnPageEnteringAsync(null).Wait();
-                Assert.Equal(Constants.DefaultServiceName, endpointPage.ServiceName);
-                Assert.Equal(MetadataPath, endpointPage.Endpoint);
-                endpointPage.ServiceName = "Service";
-                endpointPage.IncludeCustomHeaders = true;
-                endpointPage.CustomHttpHeaders = "A:b";
+                Assert.Equal(Constants.DefaultServiceName, endpointPage.UserSettings.ServiceName);
+                Assert.Equal(MetadataPath, endpointPage.UserSettings.Endpoint);
+                endpointPage.UserSettings.ServiceName = "Service";
+                endpointPage.UserSettings.IncludeCustomHeaders = true;
+                endpointPage.UserSettings.CustomHttpHeaders = "A:b";
                 endpointPage.OnPageLeavingAsync(null).Wait();
 
                 advancedPage.OnPageEnteringAsync(null).Wait();
-                Assert.True(advancedPage.UseNamespacePrefix);
-                Assert.True(advancedPage.UseDataServiceCollection);
-                Assert.True(advancedPage.MakeTypesInternal);
-                advancedPage.NamespacePrefix = "MyNamespace";
-                advancedPage.GenerateMultipleFiles = true;
-                advancedPage.UseDataServiceCollection = false;
+                Assert.True(advancedPage.UserSettings.UseNamespacePrefix);
+                Assert.True(advancedPage.UserSettings.UseDataServiceCollection);
+                Assert.True(advancedPage.UserSettings.MakeTypesInternal);
+                advancedPage.UserSettings.NamespacePrefix = "MyNamespace";
+                advancedPage.UserSettings.GenerateMultipleFiles = true;
+                advancedPage.UserSettings.UseDataServiceCollection = false;
                 advancedPage.OnPageLeavingAsync(null).Wait();
 
                 operationsPage.OnPageEnteringAsync(null).Wait();
@@ -812,25 +806,25 @@ public void ShouldPreserveState_WhenMovingBetweenPagesAndBack_WhenUpdating()
 
                 var advancedPage = wizard.AdvancedSettingsViewModel;
                 advancedPage.OnPageEnteringAsync(null).Wait();
-                advancedPage.UseDataServiceCollection = true;
-                advancedPage.MakeTypesInternal = true;
-                advancedPage.UseNamespacePrefix = true;
+                advancedPage.UserSettings.UseDataServiceCollection = true;
+                advancedPage.UserSettings.MakeTypesInternal = true;
+                advancedPage.UserSettings.UseNamespacePrefix = true;
                 advancedPage.OnPageLeavingAsync(null).Wait();
 
                 endpointPage.OnPageEnteringAsync(null).Wait();
-                Assert.Equal(savedConfig.ServiceName, endpointPage.ServiceName);
-                Assert.Equal(savedConfig.Endpoint, endpointPage.Endpoint);
-                endpointPage.IncludeCustomHeaders = true;
-                endpointPage.CustomHttpHeaders = "A:b";
+                Assert.Equal(savedConfig.ServiceName, endpointPage.UserSettings.ServiceName);
+                Assert.Equal(savedConfig.Endpoint, endpointPage.UserSettings.Endpoint);
+                endpointPage.UserSettings.IncludeCustomHeaders = true;
+                endpointPage.UserSettings.CustomHttpHeaders = "A:b";
                 endpointPage.OnPageLeavingAsync(null).Wait();
 
                 advancedPage.OnPageEnteringAsync(null).Wait();
-                Assert.True(advancedPage.UseNamespacePrefix);
-                Assert.True(advancedPage.UseDataServiceCollection);
-                Assert.True(advancedPage.MakeTypesInternal);
-                advancedPage.NamespacePrefix = "MyNamespace";
-                advancedPage.GenerateMultipleFiles = true;
-                advancedPage.UseDataServiceCollection = false;
+                Assert.True(advancedPage.UserSettings.UseNamespacePrefix);
+                Assert.True(advancedPage.UserSettings.UseDataServiceCollection);
+                Assert.True(advancedPage.UserSettings.MakeTypesInternal);
+                advancedPage.UserSettings.NamespacePrefix = "MyNamespace";
+                advancedPage.UserSettings.GenerateMultipleFiles = true;
+                advancedPage.UserSettings.UseDataServiceCollection = false;
                 advancedPage.OnPageLeavingAsync(null).Wait();
 
                 operationsPage.OnPageEnteringAsync(null).Wait();
@@ -895,7 +889,7 @@ public void ShouldReloadOperationsAndTypesForNewEndpoint_WhenEndpointIsChangedBe
             {
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
                 endpointPage.OnPageEnteringAsync(null).Wait();
-                endpointPage.Endpoint = MetadataPath;
+                endpointPage.UserSettings.Endpoint = MetadataPath;
                 endpointPage.OnPageLeavingAsync(null).Wait();
 
                 var typesPage = wizard.SchemaTypesViewModel;
@@ -910,7 +904,7 @@ public void ShouldReloadOperationsAndTypesForNewEndpoint_WhenEndpointIsChangedBe
 
                 // go back to first page and change endpoint
                 endpointPage.OnPageEnteringAsync(null).Wait();
-                endpointPage.Endpoint = MetadataPathSimple;
+                endpointPage.UserSettings.Endpoint = MetadataPathSimple;
                 endpointPage.OnPageLeavingAsync(null).Wait();
 
                 typesPage.OnPageEnteringAsync(null).Wait();
@@ -959,7 +953,7 @@ public void ShouldDeselectOperations_WhenRelatedTypeIsDeselectedBefore()
             {
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
                 endpointPage.OnPageEnteringAsync(null).Wait();
-                endpointPage.Endpoint = MetadataPath;
+                endpointPage.UserSettings.Endpoint = MetadataPath;
                 endpointPage.OnPageLeavingAsync(null).Wait();
 
                 var typesPage = wizard.SchemaTypesViewModel;
@@ -993,7 +987,7 @@ public void ShouldDeselectBoundOperations_WhenRelatedTypeIsDeselectedBefore()
             {
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
                 endpointPage.OnPageEnteringAsync(null).Wait();
-                endpointPage.Endpoint = MetadataPath;
+                endpointPage.UserSettings.Endpoint = MetadataPath;
                 endpointPage.OnPageLeavingAsync(null).Wait();
 
                 var typesPage = wizard.SchemaTypesViewModel;
@@ -1034,7 +1028,7 @@ public void UnsupportedFeaturesAreDisabledOrHidden_WhenServiceIsV3OrLess()
             using(var wizard = new ODataConnectedServiceWizard(context))
             {
                 var endpointPage = wizard.ConfigODataEndpointViewModel;
-                endpointPage.Endpoint = MetadataPathV3;
+                endpointPage.UserSettings.Endpoint = MetadataPathV3;
                 endpointPage.OnPageLeavingAsync(null).Wait();
                 Assert.Equal(Constants.EdmxVersion1, endpointPage.EdmxVersion);
 
diff --git a/test/ODataConnectedService.Tests/ViewModels/ConfigOdataEndPointViewModelTests.cs b/test/ODataConnectedService.Tests/ViewModels/ConfigOdataEndPointViewModelTests.cs
index 5b362a9f..c1649560 100644
--- a/test/ODataConnectedService.Tests/ViewModels/ConfigOdataEndPointViewModelTests.cs
+++ b/test/ODataConnectedService.Tests/ViewModels/ConfigOdataEndPointViewModelTests.cs
@@ -11,7 +11,6 @@
 using Microsoft.OData.ConnectedService;
 using Microsoft.OData.ConnectedService.Common;
 using Microsoft.OData.ConnectedService.Models;
-using Microsoft.OData.ConnectedService.Tests.Templates;
 using Microsoft.OData.ConnectedService.ViewModels;
 using Microsoft.VisualStudio.ConnectedServices;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -31,7 +30,8 @@ public void Init()
         {
             userSettings = new UserSettings();
             serviceWizard = new ODataConnectedServiceWizard(null);
-            configOdataEndPointViewModel = new ConfigODataEndpointViewModel(userSettings, serviceWizard);
+            configOdataEndPointViewModel = new ConfigODataEndpointViewModel(userSettings);
+            serviceWizard.Pages.Add(configOdataEndPointViewModel);
             CultureInfo.DefaultThreadCurrentUICulture = CultureInfo.InvariantCulture;
         }
 
@@ -55,11 +55,11 @@ public void OnPageLeavingConfigODataEndpointPageTest()
             Assert.IsTrue(pageNavigationResult.ShowMessageBoxOnFailure);
 
             //Provide a url without $metadata
-            configOdataEndPointViewModel.Endpoint = "http://mysite/ODataService";
+            configOdataEndPointViewModel.UserSettings.Endpoint = "http://mysite/ODataService";
             pageNavigationResultTask = configOdataEndPointViewModel.OnPageLeavingAsync(null);
 
             //Check if $metadata is apended if the url does not have it added at the end
-            Assert.AreEqual(configOdataEndPointViewModel.Endpoint, "http://mysite/ODataService/$metadata");
+            Assert.AreEqual(configOdataEndPointViewModel.UserSettings.Endpoint, "http://mysite/ODataService/$metadata");
 
             //Check if an exception is thrown for an invalid url and the user is notified
             pageNavigationResult = pageNavigationResultTask?.Result;
@@ -69,7 +69,7 @@ public void OnPageLeavingConfigODataEndpointPageTest()
             Assert.IsTrue(pageNavigationResult.ShowMessageBoxOnFailure);
 
 
-            configOdataEndPointViewModel.Endpoint = Path.Combine(Directory.GetCurrentDirectory(),"EdmxFile.xml");
+            configOdataEndPointViewModel.UserSettings.Endpoint = Path.Combine(Directory.GetCurrentDirectory(),"EdmxFile.xml");
             pageNavigationResultTask = configOdataEndPointViewModel.OnPageLeavingAsync(null);
 
             //Check if any errors were reported
diff --git a/test/ODataConnectedService.Tests/Views/UserSettingsTest.cs b/test/ODataConnectedService.Tests/Views/UserSettingsTest.cs
index 03e4856f..0d3daea8 100644
--- a/test/ODataConnectedService.Tests/Views/UserSettingsTest.cs
+++ b/test/ODataConnectedService.Tests/Views/UserSettingsTest.cs
@@ -5,19 +5,27 @@
 // </copyright>
 //-----------------------------------------------------------------------------------
 
+using System;
 using Microsoft.OData.ConnectedService.Models;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Xunit;
 
 namespace ODataConnectedService.Tests.Views
 {
-    [TestClass]
-    public class UserSettingsTest
+    public sealed class UserSettingsTest : IDisposable
     {
-        [TestMethod]
+        // Will be executed after every test to set test user settings to a known initial state
+        public void Dispose()
+        {
+            var userSettings = new UserSettings(configName: "TestUserSettings");
+            userSettings.MruEndpoints.Clear();
+            userSettings.Save();
+        }
+
+        [Fact]
         public void SaveSettingsWhenSaveMethodIsCalled()
         {
             // Create an instance of UserSettings
-            var userSettings = new UserSettings();
+            var userSettings = new UserSettings(configName: "TestUserSettings");
 
             // Set UserSettings
             userSettings.Endpoint = "https://service/$metadata";
@@ -28,22 +36,20 @@ public void SaveSettingsWhenSaveMethodIsCalled()
             // Save settings
             userSettings.Save();
 
-            //Load settings
-            UserSettings settings = UserSettings.Load(null);
-            Assert.AreEqual("https://service/$metadata", settings.Endpoint);
-            Assert.AreEqual("MyPrefix", settings.GeneratedFileNamePrefix);
-            Assert.AreEqual(true, settings.GenerateMultipleFiles);
-            Assert.AreEqual(true, settings.MakeTypesInternal);
-
-            // Reset User Settings
-            ResetUserSettings();
+            // Load settings
+            var settings = new UserSettings(configName: "TestUserSettings");
+            settings.Load();
+            Assert.Equal("https://service/$metadata", settings.Endpoint);
+            Assert.Equal("MyPrefix", settings.GeneratedFileNamePrefix);
+            Assert.True(settings.GenerateMultipleFiles);
+            Assert.True(settings.MakeTypesInternal);
         }
 
-        [TestMethod]
+        [Fact]
         public void AddToTopOfMruList_ShouldAddToTopWithoutDuplicatingOrExceedingMax()
         {
             // Create an instance of UserSettings
-            var userSettings = new UserSettings();
+            var userSettings = new UserSettings(configName: "TestUserSettings");
 
             var endpoint1 = "https://service1/$metadata";
             var endpoint2 = "https://service2/$metadata";
@@ -58,45 +64,36 @@ public void AddToTopOfMruList_ShouldAddToTopWithoutDuplicatingOrExceedingMax()
             var endpoint11 = "https://service11/$metadata";
 
             // Add an endpoint.
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint1);
-            Assert.AreEqual(1, userSettings.MruEndpoints.Count);            
+            userSettings.AddMruEndpoint(endpoint1);
+            Assert.Single(userSettings.MruEndpoints);            
 
             // Add another endpoint.The latest endpoint to be added is at the top of the MruList.
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint2);
-            Assert.AreEqual(2, userSettings.MruEndpoints.Count);
-            Assert.AreEqual(endpoint2, userSettings.MruEndpoints[0]);
-            Assert.AreEqual(endpoint1, userSettings.MruEndpoints[1]);
+            userSettings.AddMruEndpoint(endpoint2);
+            Assert.Equal(2, userSettings.MruEndpoints.Count);
+            Assert.Equal(endpoint2, userSettings.MruEndpoints[0]);
+            Assert.Equal(endpoint1, userSettings.MruEndpoints[1]);
 
             // Add duplicate endpoint, Count should remain the same. But the item is moved to top of the MruList.
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint1);
-            Assert.AreEqual(2, userSettings.MruEndpoints.Count);
-            Assert.AreEqual(endpoint1, userSettings.MruEndpoints[0]);
-            Assert.AreEqual(endpoint2, userSettings.MruEndpoints[1]);
+            userSettings.AddMruEndpoint(endpoint1);
+            Assert.Equal(2, userSettings.MruEndpoints.Count);
+            Assert.Equal(endpoint1, userSettings.MruEndpoints[0]);
+            Assert.Equal(endpoint2, userSettings.MruEndpoints[1]);
 
-            //Add 9 more endpoints. Total should not exceed 10
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint3);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint4);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint5);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint6);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint7);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint8);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint9);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint10);
-            UserSettings.AddToTopOfMruList(userSettings?.MruEndpoints, endpoint11);
-            Assert.AreEqual(10, userSettings.MruEndpoints.Count);
-            //endpoint11 is the latest so on top in the MruList
-            Assert.AreEqual(endpoint11, userSettings.MruEndpoints[0]);
-            //endpoint2 is the least recent hence removed from the list
-            Assert.IsFalse(userSettings.MruEndpoints.Contains(endpoint2));
-
-            // Reset User Settings
-            ResetUserSettings();
-        }
-
-        private void ResetUserSettings()
-        {
-            var settings = new UserSettings();
-            settings.Save();
+            // Add 9 more endpoints. Total should not exceed 10
+            userSettings.AddMruEndpoint(endpoint3);
+            userSettings.AddMruEndpoint(endpoint4);
+            userSettings.AddMruEndpoint(endpoint5);
+            userSettings.AddMruEndpoint(endpoint6);
+            userSettings.AddMruEndpoint(endpoint7);
+            userSettings.AddMruEndpoint(endpoint8);
+            userSettings.AddMruEndpoint(endpoint9);
+            userSettings.AddMruEndpoint(endpoint10);
+            userSettings.AddMruEndpoint(endpoint11);
+            Assert.Equal(10, userSettings.MruEndpoints.Count);
+            // endpoint11 is the latest so on top in the MruList
+            Assert.Equal(endpoint11, userSettings.MruEndpoints[0]);
+            // endpoint2 is the least recent hence removed from the list
+            Assert.Contains(userSettings.MruEndpoints, d => !d.Contains(endpoint2));
         }
     }
 }