Merge remote-tracking branch 'Azure/master' into tiano-deployment-refactor

# Conflicts:
#	src/Resources/Resources/ChangeLog.md

Author: Tiano2017

documentation/development-docs/azure-powershell-developer-guide.md

@@ -143,7 +143,7 @@ Before submitting a design review, please be sure that you have read the documen
 
 Please submit a design review here: https://github.com/Azure/azure-powershell-cmdlet-review-pr
 
-_Note_: You will need to be part of the `GitHub Azure` org to see this repository. Please go to [this link](aka.ms/azuregithub) to become part of the `Azure` org.
+_Note_: You will need to be part of the `GitHub Azure` org to see this repository. Please go to [this link](https://aka.ms/azuregithub) to become part of the `Azure` org.
 
 We recommend using the `platyPS` module to easily generate markdown files that contains the above information and including the files in the design submission.
 

documentation/development-docs/design-guidelines/parameter-best-practices.md

@@ -6,23 +6,23 @@
 
 The following are naming conventions to keep in mind when coming up with a name for your parameters.
 
-In addition, a recommended list of parameter names can be found [here](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/standard-cmdlet-parameter-names-and-types).
+In addition, a recommended list of parameter names can be found [here](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/standard-cmdlet-parameter-names-and-types).
 
 #### Standard Parameter Name
 
-From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/strongly-encouraged-development-guidelines#use-standard-parameter-names):
+From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/strongly-encouraged-development-guidelines#use-standard-parameter-names):
 
 > _Your cmdlet should use standard parameter names so that the user can quickly determine what a particular parameter means. If a more specific name is required, use a standard parameter name, and then specify a more specific name as an alias. For example, the `Get-Service` cmdlet has a parameter that has a generic name (**Name**) and a more specific alias (**ServiceName**). Both terms can be used to specify the parameter._
 
 #### Pascal Case
 
-Similar to cmdlets, parameters should follow pascal casing.From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/strongly-encouraged-development-guidelines#use-pascal-case-for-parameter-names):
+Similar to cmdlets, parameters should follow pascal casing.From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/strongly-encouraged-development-guidelines#use-pascal-case-for-parameter-names):
 
 > _Use Pascal case for parameter names. In other words, capitalize the first letter of each word in the parameter name, including the first letter of the name._
 
 #### Singularity
 
-From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/strongly-encouraged-development-guidelines#use-singular-parameter-names):
+From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/strongly-encouraged-development-guidelines#use-singular-parameter-names):
 
 > _Avoid using plural names for parameters whose value is a single element. This includes parameters that take arrays or lists because the user might supply an array or list with only one element._
 >
@@ -40,15 +40,15 @@ The type of parameters should always be defined; a parameter should never be of
 
 #### Consistent Parameter Types
 
-From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/strongly-encouraged-development-guidelines#use-consistent-parameter-types):
+From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/strongly-encouraged-development-guidelines#use-consistent-parameter-types):
 
 > _When the same parameter is used by multiple cmdlets, always use the same parameter type. For example, if the **Process** parameter is an **Int16** type for one cmdlet, do not make the **Process** parameter for another cmdlet a **UInt16** type._
 
 #### Array vs. Enumerable Types
 
 For parameters that require a collection of elements to be provided, use an array instead of any other enumerable type to represent this collection.
 
-From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/strongly-encouraged-development-guidelines#support-arrays-for-parameters):
+From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/strongly-encouraged-development-guidelines#support-arrays-for-parameters):
 
 > _Frequently, users must perform the same operation against multiple arguments. For these users, a cmdlet should accept an array as parameter input so that a user can pass the arguments into the parameter as a Windows PowerShell variable. For example, the `Get-Process` cmdlet uses an array for the strings that identify the names of the processes to retrieve._
 
@@ -126,7 +126,7 @@ The following are naming conventions to keep in mind when coming up with a name
 
 #### Pascal Case
 
-Similar to parameters (mentioned above), parameter set names should follow pascal casing. From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/strongly-encouraged-development-guidelines#use-pascal-case-for-cmdlet-names-sd02):
+Similar to parameters (mentioned above), parameter set names should follow pascal casing. From the [_Strongly Encouraged Development Guidelines_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/strongly-encouraged-development-guidelines#use-pascal-case-for-cmdlet-names-sd02):
 
 > _Use Pascal case for cmdlet names. In other words, capitalize the first letter of the verb and all terms used in the noun. For example, "Clear-ItemProperty"._
 
@@ -136,22 +136,22 @@ The following are guidelines that should be followed when working with the attri
 
 #### Mutually Exclusive Parameter Sets
 
-For PowerShell to determine which parameter set a user is intending to use with a set of provided parameters, the parameter sets need to be designed in such a way that they are mutually exclusive. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/parameter-attribute-declaration#remarks):
+For PowerShell to determine which parameter set a user is intending to use with a set of provided parameters, the parameter sets need to be designed in such a way that they are mutually exclusive. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/parameter-attribute-declaration#remarks):
 
 > _Each parameter set must have at least one unique parameter. Good cmdlet design indicates this unique parameter should also be mandatory if possible. If your cmdlet is designed to be run without parameters, the unique parameter cannot be mandatory._
 
 #### Positional Parameters Limit
 
-It is possible to call a PowerShell cmdlet without providing the parameter names, but just the values you would like to pass through. This is done by specifying the position at which the value of each parameter should be provided by using the `Position` property for a parameter.  However, when there are too many positional parameters in a single parameter set, it can be difficult for the user to remember the exact ordering in which the parameter values should be provided. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/parameter-attribute-declaration#remarks):
+It is possible to call a PowerShell cmdlet without providing the parameter names, but just the values you would like to pass through. This is done by specifying the position at which the value of each parameter should be provided by using the `Position` property for a parameter.  However, when there are too many positional parameters in a single parameter set, it can be difficult for the user to remember the exact ordering in which the parameter values should be provided. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/parameter-attribute-declaration#remarks):
 
 > _When you specify positional parameters, limit the number of positional parameters in a parameter set to less than five. And, positional parameters do not have to be contiguous. Positions 5, 100, and 250 work the same as positions 0, 1, and 2._
 
-In addition, there should be no two parameters with the same position in the same parameter set. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/parameter-attribute-declaration#remarks):
+In addition, there should be no two parameters with the same position in the same parameter set. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/parameter-attribute-declaration#remarks):
 
 > _No parameter set should contain more than one positional parameter with the same position._
 
 #### ValueFromPipeline Limit
 
-Allowing the user to pipe an object from one cmdlet to another is a major scenario in PowerShell, but allowing multiple parameters in the same parameter set to accept their value from the pipeline can cause issues. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/developer/cmdlet/parameter-attribute-declaration#remarks):
+Allowing the user to pipe an object from one cmdlet to another is a major scenario in PowerShell, but allowing multiple parameters in the same parameter set to accept their value from the pipeline can cause issues. From the remarks section of [_Parameter Attribute Declaration_](https://docs.microsoft.com/en-us/powershell/scripting/developer/cmdlet/parameter-attribute-declaration#remarks):
 
-> _Only one parameter in a parameter set should declare ValueFromPipeline = true. Multiple parameters can define ValueFromPipelineByPropertyName = true._
+> _Only one parameter in a parameter set should declare ValueFromPipeline = true. Multiple parameters can define ValueFromPipelineByPropertyName = true._

src/Accounts/Accounts.Test/AutoSaveSettingOnLoadingTests.cs

@@ -0,0 +1,122 @@
+// ----------------------------------------------------------------------------------
+//
+// Copyright Microsoft Corporation
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// ---------------------------------------------------------------------------------
+
+using Microsoft.Azure.Commands.Common.Authentication;
+using Microsoft.Azure.Commands.Common.Authentication.Abstractions;
+using Microsoft.Azure.Commands.Common.Authentication.Core;
+using Microsoft.Azure.Commands.Common.Authentication.Models;
+using Microsoft.Azure.Commands.Common.Authentication.Properties;
+using Microsoft.Azure.Commands.ResourceManager.Common;
+using Microsoft.WindowsAzure.Commands.ScenarioTest;
+using Microsoft.WindowsAzure.Commands.Utilities.Common;
+using Newtonsoft.Json;
+using System;
+using System.IO;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Microsoft.Azure.Commands.Profile.Test
+{
+    public class AutoSaveSettingOnLoadingTests
+    {
+        private MemoryDataStore dataStore;
+        private string profileBasePath;
+        private string settingsPath;
+
+        public AutoSaveSettingOnLoadingTests(ITestOutputHelper output)
+        {
+            dataStore = new MemoryDataStore();
+            profileBasePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            settingsPath = Path.Combine(profileBasePath, Resources.AzureDirectoryName);
+            settingsPath = Path.Combine(settingsPath, ContextAutosaveSettings.AutoSaveSettingsFile);
+        }
+
+        internal string HookSettingFile(string hook)
+        {
+            var result = new ContextAutosaveSettings
+            {
+                CacheDirectory = hook,
+                ContextDirectory = hook,
+                Mode = ContextSaveMode.CurrentUser,
+                CacheFile = "TokenCache.dat",
+                ContextFile = "AzureRmContext.json"
+            };
+
+            var backupPath = String.Empty;
+            if (!dataStore.FileExists(settingsPath))
+            {
+                string directoryPath = Path.GetDirectoryName(settingsPath);
+                if (!dataStore.DirectoryExists(directoryPath))
+                {
+                    dataStore.CreateDirectory(directoryPath);
+                }
+            }
+            else
+            {
+                backupPath = BackupSetting();
+            }
+            dataStore.WriteFile(settingsPath, JsonConvert.SerializeObject(result));
+            return backupPath;
+        }
+
+        internal string BackupSetting()
+        {
+            var backupPath = settingsPath + ".bak";
+            dataStore.CopyFile(settingsPath, backupPath);
+            return backupPath;
+        }
+
+        internal void RestoreSetting(string backupPath)
+        {
+            if(dataStore.FileExists(backupPath))
+            {
+                dataStore.DeleteFile(settingsPath);
+                dataStore.CopyFile(backupPath, settingsPath);
+                dataStore.DeleteFile(backupPath);
+            }
+            else
+            {
+                dataStore.DeleteFile(settingsPath);
+            }
+        }
+
+        [Fact]
+        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        public void DisableAutoSaveWhenSettingFileBreaks()
+        {
+            string faker = Path.Combine(Directory.GetParent(profileBasePath).ToString(), "faker");
+            faker = Path.Combine(faker,Resources.AzureDirectoryName);
+            var backupPath = HookSettingFile(faker);
+
+            try
+            {
+                AzureSessionInitializer.CreateOrReplaceSession(dataStore);
+                TestMockSupport.RunningMocked = true;
+                var cmdlet = new ConnectAzureRmAccountCommand();
+                cmdlet.OnImport();
+                Assert.Equal(ContextSaveMode.Process, AzureSession.Instance.ARMContextSaveMode);
+                Assert.Equal(typeof(ResourceManagerProfileProvider), AzureRmProfileProvider.Instance.GetType());
+                var afterModified = dataStore.ReadFileAsText(settingsPath);
+                var newSetting = JsonConvert.DeserializeObject<ContextAutosaveSettings>(afterModified) as ContextAutosaveSettings;
+                Assert.NotNull(newSetting);
+                Assert.Equal(ContextSaveMode.CurrentUser, newSetting.Mode);
+                Assert.Equal(typeof(AuthenticationStoreTokenCache), AzureSession.Instance.TokenCache.GetType());
+            }
+            finally
+            {
+                RestoreSetting(backupPath);
+            }
+        }
+    }
+}

src/Accounts/Accounts/Account/ConnectAzureRmAccount.cs

@@ -14,14 +14,15 @@
 
 using Microsoft.Azure.Commands.Common.Authentication;
 using Microsoft.Azure.Commands.Common.Authentication.Abstractions;
-using Microsoft.Azure.Commands.Common.Authentication.Abstractions.Core;
+using Microsoft.Azure.Commands.Common.Authentication.Core;
 using Microsoft.Azure.Commands.Common.Authentication.Models;
-using Microsoft.Azure.Commands.Profile.Models;
 using Microsoft.Azure.Commands.Profile.Models.Core;
 using Microsoft.Azure.Commands.ResourceManager.Common;
 using Microsoft.WindowsAzure.Commands.Utilities.Common;
+using Newtonsoft.Json;
 using System;
 using System.Management.Automation;
+using System.IO;
 using System.Security;
 using Microsoft.Azure.Commands.Profile.Properties;
 using Microsoft.Azure.Commands.Profile.Common;
@@ -387,7 +388,11 @@ public void OnImport()
                     autoSaveEnabled = localAutosave;
                 }
 
-                InitializeProfileProvider(autoSaveEnabled);
+                if(!InitializeProfileProvider(autoSaveEnabled))
+                {
+                    DisableAutosave(AzureSession.Instance);
+                }
+
                 IServicePrincipalKeyStore keyStore =
 // TODO: Remove IfDef
 #if NETSTANDARD
@@ -404,5 +409,22 @@ public void OnImport()
             }
 #endif
         }
+
+        private void DisableAutosave(IAzureSession session)
+        {
+            session.ARMContextSaveMode = ContextSaveMode.Process;
+            var memoryCache = session.TokenCache as AuthenticationStoreTokenCache;
+            if (memoryCache == null)
+            {
+                var diskCache = session.TokenCache as ProtectedFileTokenCache;
+                memoryCache = new AuthenticationStoreTokenCache(new AzureTokenCache());
+                if (diskCache != null && diskCache.Count > 0)
+                {
+                    memoryCache.Deserialize(diskCache.Serialize());
+                }
+
+                session.TokenCache = memoryCache;
+            }
+        }
     }
 }

src/Accounts/Accounts/AutoSave/DisableAzureRmContextAutosave.cs

@@ -13,17 +13,13 @@
 // ----------------------------------------------------------------------------------
 
 using Microsoft.Azure.Commands.Common.Authentication;
-// TODO: Remove IfDef
-#if NETSTANDARD
-using Microsoft.Azure.Commands.Common.Authentication.Core;
-#endif
 using Microsoft.Azure.Commands.Common.Authentication.Abstractions;
+using Microsoft.Azure.Commands.Common.Authentication.Core;
 using Microsoft.Azure.Commands.Profile.Common;
 using Microsoft.Azure.Commands.ResourceManager.Common;
-using Microsoft.WindowsAzure.Commands.Common;
 using Newtonsoft.Json;
-using System.IO;
 using System.Management.Automation;
+using System.IO;
 
 namespace Microsoft.Azure.Commands.Profile.Context
 {
@@ -64,7 +60,7 @@ public override void ExecuteCmdlet()
             }
         }
 
-        void DisableAutosave(IAzureSession session, bool writeAutoSaveFile, out ContextAutosaveSettings result)
+        protected void DisableAutosave(IAzureSession session, bool writeAutoSaveFile, out ContextAutosaveSettings result)
         {
             var store = session.DataStore;
             string tokenPath = Path.Combine(session.TokenCacheDirectory, session.TokenCacheFile);

src/Accounts/Accounts/ChangeLog.md

@@ -18,6 +18,8 @@
         - Additional information about change #1
 -->
 ## Upcoming Release
+* Disable context auto saving when AzureRmContext.json not available
+* Update the reference to Azure Powershell Common to 1.3.5-preview
 
 ## Version 1.7.0
 * Updated Add-AzEnvironment and Set-AzEnvironment to accept parameters AzureAttestationServiceEndpointResourceId and AzureAttestationServiceEndpointSuffix