fix merge conflicts

Author: blueww

ChangeLog.md

@@ -1,3 +1,89 @@
+## 3.4.0 - February 2020
+
+#### Az.CosmosDB
+* Added cmdlets for Gremlin, MongoDB, Cassandra and Table APIs.
+* Updated .NET SDK Version to 1.0.1
+* Added parameters ConflictResolutionPolicyMode, ConflictResolutionPolicyPath and ConflictResolutionPolicyPath in Set-AzCosmosDBSqlContainer.
+* Added new cmdlets for Sql API : New-CosmosDBSqlSpatialSpec, New-CosmosDBSqlCompositePath, New-CosmosDBSqlIncludedPathIndex, New-CosmosDBSqlIncludedPath
+
+### Highlights since the last major release
+* Az.CosmosDB initial version 0.1.0 released
+* Az.Network ConnectionMonitor V2 support added
+
+#### Az.Accounts
+* Disable context auto saving when AzureRmContext.json not available
+* Update the reference to Azure Powershell Common to 1.3.5-preview
+
+#### Az.ApiManagement
+* **Get-AzApiManagementApiSchema** Fixed getting Open-Api Schema associated with an API
+    https://github.com/Azure/azure-powershell/issues/10626
+* **New-AzApiManagementProduct*** and **Set-AzApiManagementProduct**
+  - Fix documentation for https://github.com/Azure/azure-powershell/issues/10472
+* **Set-AzApiManagementApi**
+    Added example to show how to update the ServiceUrl using the cmdlet
+
+#### Az.Compute
+* Limit the number of VM status to 100 to avoid throttling when Get-AzVM -Status is performed without VM name.
+* Add Update-AzDiskEncryptionSet cmdlet
+* Add EncryptionType and DiskEncryptionSetId parameters to the following cmdlets:
+    - New-AzDiskUpdateConfig, New-AzSnapshotUpdateConfig
+* Add ColocationStatus parameter to Get-AzProximityPlacementGroup cmdlet.
+
+#### Az.DataFactory
+* Update ADF .Net SDK version to 4.7.0
+
+#### Az.DeploymentManager
+* Adds LIST operations for resources
+* Adds capability for performing operations on Health Check steps
+
+#### Az.HDInsight
+* Fix document error of New-AzHDInsightCluster.
+
+#### Az.KeyVault
+* Add Name alias to VaultName attribute to make Remove-AzureKeyVault consistent with New-AzureKeyVault.
+
+#### Az.Network
+* New example added to Set-AzNetworkWatcherConfigFlowLog.md to demonstrate Traffic Analytics disable scenario.
+* Add support for assigning management IP configuration to Azure Firewall - a dedicated subnet and Public IP that the firewall will use for its management traffic
+    - Updated New-AzFirewall cmdlet:
+        - Added parameter -ManagementPublicIpAddress (not mandatory) which accepts a Public IP Address object
+        - Added method SetManagementIpConfiguration on firewall object - requires a subnet and a Public IP address as input - subnet name must be 'AzureFirewallManagementSubnet'
+* Corrected Get-AzNetworkSecurityGroup examples to show examples for NSG's instead of network interfaces.
+* Fixed typo in New-AzVpnSite command that was preventing resource id completer from completing a parameter.
+* Added support for Url Confiugration in Rewrite Rules Action Set in the Application Gateway
+    - New cmdlets added:
+        - New-AzApplicationGatewayRewriteRuleUrlConfiguration
+    - Cmdlets updated with optional parameter - UrlConfiguration
+        - New-AzApplicationGatewayRewriteRuleActionSet
+* Add suppport for NetworkWatcher ConnectionMonitor version 2 resources
+
+#### Az.PolicyInsights
+* Support evaluating compliance prior to determining what resource to remediate
+    - Add '-ResourceDiscoverMode' parameter to Start-AzPolicyRemediation
+* Add Get-AzPolicyMetadata cmdlet for getting policy metadata resources
+* Updated Get-AzPolicyState and Get-AzPolicyStateSummary for API version 2019-10-01
+
+#### Az.RecoveryServices
+* Azure Site Recovery support for removing a replicated disk.
+* Azure Backup added support for adding tags while creating a Recovery Services Vault.
+
+#### Az.Resources
+* Make -Scope optional in *-AzPolicyAssignment cmdlets with default to context subscription
+* Add examples of creating ADServicePrincipal with password and key credential
+
+#### Az.Sql
+Fix New-AzSqlDatabaseSecondary cmdlet to check for PartnerDatabaseName existence instead of DatabaseName existence.
+
+#### Az.Storage
+* Support set Table/Queue Encryption Keytype in Create Storage Account
+    - New-AzStorageAccount
+* Show RequestId when StorageException don't have ExtendedErrorInformation
+* Fix the Example 6 of cmdlet Start-AzStorageBlobCopy
+
+#### Az.Websites
+* Set-AzWebapp and Set-AzWebappSlot supports AlwaysOn, MinTls and FtpsState properties
+* Fixing issue where setting HttpsOnly along with changing AppservicePlan at the same time using the single Set-AzWebApp Command, was resetting HttpsOnly to default value
+
 ## 3.3.0 - January 2020
 #### Az.Accounts
 * Updated Add-AzEnvironment and Set-AzEnvironment to accept parameters AzureAttestationServiceEndpointResourceId and AzureAttestationServiceEndpointSuffix

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);
+            }
+        }
+    }
+}