/// <summary>
 /// Creates or Updates the IdentityProvider configuration.
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='resourceGroupName'>
 /// The name of the resource group.
 /// </param>
 /// <param name='serviceName'>
 /// The name of the API Management service.
 /// </param>
 /// <param name='identityProviderName'>
 /// Identity Provider Type identifier. Possible values include: 'facebook',
 /// 'google', 'microsoft', 'twitter', 'aad', 'aadB2C'
 /// </param>
 /// <param name='parameters'>
 /// Create parameters.
 /// </param>
 /// <param name='ifMatch'>
 /// ETag of the Entity. Not required when creating an entity, but required when
 /// updating an entity.
 /// </param>
 public static IdentityProviderContract CreateOrUpdate(this IIdentityProviderOperations operations, string resourceGroupName, string serviceName, string identityProviderName, IdentityProviderCreateContract parameters, string ifMatch = default(string))
 {
     return(operations.CreateOrUpdateAsync(resourceGroupName, serviceName, identityProviderName, parameters, ifMatch).GetAwaiter().GetResult());
 }
 /// <summary>
 /// Creates or Updates the IdentityProvider configuration.
 /// </summary>
 /// <param name='operations'>
 /// The operations group for this extension method.
 /// </param>
 /// <param name='resourceGroupName'>
 /// The name of the resource group.
 /// </param>
 /// <param name='serviceName'>
 /// The name of the API Management service.
 /// </param>
 /// <param name='identityProviderName'>
 /// Identity Provider Type identifier. Possible values include: 'facebook',
 /// 'google', 'microsoft', 'twitter', 'aad', 'aadB2C'
 /// </param>
 /// <param name='parameters'>
 /// Create parameters.
 /// </param>
 /// <param name='ifMatch'>
 /// ETag of the Entity. Not required when creating an entity, but required when
 /// updating an entity.
 /// </param>
 /// <param name='cancellationToken'>
 /// The cancellation token.
 /// </param>
 public static async Task <IdentityProviderContract> CreateOrUpdateAsync(this IIdentityProviderOperations operations, string resourceGroupName, string serviceName, string identityProviderName, IdentityProviderCreateContract parameters, string ifMatch = default(string), CancellationToken cancellationToken = default(CancellationToken))
 {
     using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, serviceName, identityProviderName, parameters, ifMatch, null, cancellationToken).ConfigureAwait(false))
     {
         return(_result.Body);
     }
 }
        public async Task CreateListUpdateDelete()
        {
            Environment.SetEnvironmentVariable("AZURE_TEST_MODE", "Playback");
            using (MockContext context = MockContext.Start(this.GetType()))
            {
                var testBase = new ApiManagementTestBase(context);
                testBase.TryCreateApiManagementService();

                try
                {
                    // create facebook external identity provider
                    string clientId     = TestUtilities.GenerateName("clientId");
                    string clientSecret = TestUtilities.GenerateName("clientSecret");

                    var identityProviderCreateParameters = new IdentityProviderCreateContract(clientId, clientSecret);

                    var identityProviderContract = testBase.client.IdentityProvider.CreateOrUpdate(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook,
                        identityProviderCreateParameters);

                    Assert.NotNull(identityProviderContract);
                    Assert.Equal(IdentityProviderType.Facebook, identityProviderContract.IdentityProviderContractType);
                    Assert.NotNull(identityProviderContract.ClientId);
                    Assert.NotNull(identityProviderContract.ClientSecret);
                    Assert.Equal(clientId, identityProviderContract.ClientId);
                    Assert.Equal(clientSecret, identityProviderContract.ClientSecret);
                    Assert.Equal(IdentityProviderType.Facebook, identityProviderContract.IdentityProviderContractType);

                    // list
                    var listIdentityProviders = testBase.client.IdentityProvider.ListByService(testBase.rgName, testBase.serviceName);

                    Assert.NotNull(listIdentityProviders);
                    Assert.True(listIdentityProviders.GetEnumerator().ToIEnumerable().Count() >= 1);

                    // get the entity tag
                    var identityProviderTag = await testBase.client.IdentityProvider.GetEntityTagAsync(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook);

                    Assert.NotNull(identityProviderTag);
                    Assert.NotNull(identityProviderTag.ETag);

                    // patch identity provider
                    string patchedSecret = TestUtilities.GenerateName("clientSecret");
                    testBase.client.IdentityProvider.Update(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook,
                        new IdentityProviderUpdateParameters
                    {
                        ClientSecret = patchedSecret
                    },
                        identityProviderTag.ETag);

                    // get to check it was patched
                    identityProviderContract = await testBase.client.IdentityProvider.GetAsync(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook);

                    Assert.NotNull(identityProviderContract);
                    Assert.Equal(IdentityProviderType.Facebook, identityProviderContract.IdentityProviderContractType);
                    Assert.Null(identityProviderContract.ClientSecret);
                    Assert.Equal(clientId, identityProviderContract.ClientId);

                    // get the tag again
                    identityProviderTag = await testBase.client.IdentityProvider.GetEntityTagAsync(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook);

                    var secret = await testBase.client.IdentityProvider.ListSecretsAsync(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook);

                    Assert.Equal(patchedSecret, secret.ClientSecret);

                    // delete the identity provider
                    testBase.client.IdentityProvider.Delete(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook,
                        identityProviderTag.ETag);

                    // get the deleted identity provider to make sure it was deleted
                    try
                    {
                        testBase.client.IdentityProvider.Get(testBase.rgName, testBase.serviceName, IdentityProviderType.Facebook);
                        throw new Exception("This code should not have been executed.");
                    }
                    catch (ErrorResponseException ex)
                    {
                        Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
                    }
                }
                finally
                {
                    testBase.client.IdentityProvider.Delete(
                        testBase.rgName,
                        testBase.serviceName,
                        IdentityProviderType.Facebook,
                        "*");
                }
            }
        }