Exécuter des tests d’intégration automatisés

En tant que développeur, vous voulez exécuter des tests d’intégration automatisés sur les applications que vous développez. Appeler votre API protégée par la plateforme d’identité Microsoft (ou d’autres API protégées comme Microsoft Graph) dans des tests d’intégration automatisés est une opération difficile. Microsoft Entra ID nécessite souvent une invite de connexion utilisateur interactive, difficile à automatiser. Cet article explique comment vous pouvez utiliser un flux non interactif, appelé ROPC (octroi d’informations d’identification par mot de passe du propriétaire des ressources), pour connecter automatiquement des utilisateurs à des fins de test.

Pour préparer vos tests d’intégration automatisés, créez des utilisateurs de test, créez et configurez une inscription d’application et apportez d’éventuelles modifications de configuration à votre locataire. Certaines de ces étapes nécessitent des privilèges administratifs. Créez un locataire de test distinct dont vous êtes administrateur pour pouvoir exécuter vos tests d’intégration automatisés de manière sécurisée et efficace.

Créer un locataire de test distinct

L’utilisation du flux d’authentification ROPC est risquée dans un environnement de production, donc créez un locataire distinct pour tester vos applications. Vous pouvez utiliser un locataire de test existant, mais vous devez être administrateur dans ce locataire, car certaines des étapes suivantes nécessitent des privilèges administratifs.

Création et configuration d’un coffre de clés

Nous vous recommandons de stocker de manière sécurisée les noms d’utilisateur de test et les mots de passe sous forme de secrets dans Azure Key Vault. Quand vous exécutez les tests ultérieurement, ceux-si s’exécutent dans le contexte d’un principal de sécurité. Le principal de sécurité est un utilisateur Microsoft Entra si vous exécutez les tests localement (par exemple, dans Visual Studio ou Visual Studio Code), ou bien un principal de service ou une identité managée si vous exécutez les tests dans Azure Pipelines ou une autre ressource Azure. Le principal de sécurité doit être autorisé à lire et lister les secrets pour que l’exécuteur de tests puisse obtenir les noms d’utilisateur de test et les mots de passe auprès de votre coffre de clés. Pour plus d’informations, consultez Authentification dans Azure Key Vault.

1. Créez un coffre de clés si vous n’en avez pas encore un.
2. Notez la valeur de la propriété URI du coffre (similaire à https://<your-unique-keyvault-name>.vault.azure.net/), utilisée dans l’exemple de test mentionné plus loin dans cet article.
3. Affectez une stratégie d’accès pour le principal de sécurité qui exécute les tests. Autorisez l’utilisateur, le principal de service ou l’identité managée à obtenir et lister les secrets dans le coffre de clés.

Créer des utilisateurs de test

Créez des utilisateurs de test dans votre locataire à des fins de test. Étant donné que les utilisateurs de test ne sont pas des humains réels, nous vous recommandons d’attribuer des mots de passe complexes et de stocker ces mots de passe en toute sécurité en tant que secrets dans Azure Key Vault.

1. Connectez-vous au Centre d’administration de Microsoft Entra au minimum en tant qu’Administrateur d’application cloud.
2. Parcourez Entra ID>, Utilisateurs.
3. Sélectionnez Nouvel utilisateur et créez un ou plusieurs comptes d’utilisateur de test dans votre annuaire.
4. L’exemple de test mentionné plus loin dans cet article utilise un seul utilisateur de test. Ajoutez le nom d’utilisateur de test et le mot de passe sous forme de secrets dans le coffre de clés que vous avez créé précédemment. Ajoutez le nom d’utilisateur sous forme de secret nommé « TestUserName » et le mot de passe sous forme de secret nommé « TestPassword ».

Créer et configurer une inscription d’application

Inscrivez une application qui sert d’application cliente lors de l’appel d’API pendant les tests. Ce ne doit pas* être la même application que celle que vous avez peut-être déjà en production. Vous devez disposer d’une application distincte à utiliser uniquement à des fins de test.

Inscrire une application

Créer une inscription d’application. Vous pouvez suivre les étapes du guide de démarrage rapide de l’inscription de l’application et prendre note de l’identifiant d’application (client), qui est utilisé dans l’exemple de test plus loin dans cet article.

Activer votre application pour les flux clients publics

Le flux ROPC étant un flux client public, vous avez besoin d’activer votre application pour les flux clients publics. À partir de l’inscription de votre application dans le centre d’administration Microsoft Entra, accédez à Authentification>Paramètres avancés>Autoriser les flux clients publics. Définissez le bouton bascule sur Oui.

Acceptez les autorisations à utiliser lors des tests

Étant donné que ROPC n’est pas un flux interactif, vous ne serez pas invité à utiliser un écran de consentement pour les donner au moment de l’exécution. Donnez votre consentement préalable aux autorisations pour éviter les erreurs lors de l'acquisition de jetons.

Ajoutez les autorisations à votre application. N’ajoutez pas d’autorisations sensibles ou à privilèges élevés à l’application, nous vous recommandons d’étendre vos scénarios de test à des scénarios d’intégration de base autour de l’intégration avec l’ID Microsoft Entra.

À partir de l’inscription de votre application dans le centre d’administration Microsoft Entra, accédez à Autorisations de l’API>Ajouter une autorisation. Ajoutez les autorisations dont vous avez besoin pour appeler les API que vous utilisez. Un exemple de test donné plus loin dans cet article utilise les autorisations https://graph.microsoft.com/User.Read et https://graph.microsoft.com/User.ReadBasic.All.

Une fois les autorisations ajoutées, vous devez leur donner votre consentement. L’acceptation des autorisations dépend du fait que votre application de test se trouve ou non dans le même locataire que l’inscription de l’application et du fait que vous êtes ou non administrateur dans le locataire.

L’application et l’inscription de l’application se trouvent dans le même locataire et vous êtes administrateur

Si vous envisagez de tester votre application dans le même locataire que celui dans lequel vous l’avez inscrite et que vous êtes administrateur dans ce locataire, vous pouvez consentir aux autorisations du Centre d’administration Microsoft Entra. Dans l’inscription de votre application dans le portail Azure, accédez à Autorisations de l’API et sélectionnez le bouton Accorder un consentement d’administrateur pour <nom_de_votre_locataire> en regard du bouton Ajouter une autorisation, puis sélectionnez Oui pour confirmer.

L’application et l’inscription de l’application se trouvent dans des locataires différents ou vous n’êtes pas administrateur

Si vous ne prévoyez pas de tester votre application dans le même locataire dans lequel vous l’avez inscrite, ou si vous n’êtes pas administrateur dans votre locataire, vous ne pouvez pas consentir aux autorisations du Centre d’administration Microsoft Entra. Vous pouvez quand même donner votre consentement à certaines autorisations, en déclenchant une invite de connexion dans un navigateur web.

Accédez au Centre d’administration Microsoft Entra, accédez auxinscriptions> d’applications Entra ID> Sélectionnez votre application dans la liste. > allez à Authentification>Configurations de la plateforme>Ajouter une plateforme>Web. Ajoutez l’URI de redirection "https://localhost", puis sélectionnez Configurer.

Il n’existe aucun moyen pour les utilisateurs non administrateurs de préconsenter via le portail Azure. Envoyez donc la requête suivante dans un navigateur. Lorsque vous êtes invité à utiliser l’écran de connexion, connectez-vous avec un compte de test que vous avez créé à l’étape précédente. Acceptez les autorisations qui vous sont proposées. Vous devrez peut-être répéter cette étape pour chaque API à appeler et chaque utilisateur de test à utiliser.

// Line breaks for legibility only

https://login.microsoftonline.com/{tenant}/oauth2/v2.0/authorize?
client_id={your_client_ID}
&response_type=code
&redirect_uri=https://localhost
&response_mode=query
&scope={resource_you_want_to_call}/.default
&state=12345

Remplacez {tenant} par votre ID de locataire, {your_client_ID} par l’ID client de votre application et {resource_you_want_to_call} par l’URI d’identificateur (par exemple, «https://graph.microsoft.com" ;) ou l’ID d’application de l’API que vous essayez d’accéder.

Exclure des applications et utilisateurs de test de votre stratégie MFA

Votre locataire a probablement une stratégie d’accès conditionnel qui nécessite une authentification multifacteur (MFA) pour tous les utilisateurs, comme recommandé par Microsoft. L’authentification multifacteur (MFA) ne fonctionne pas avec ROPC. Vous devez donc exclure vos applications et utilisateurs de test de cette exigence.

Pour exclure des comptes d’utilisateur :

1. Connectez-vous au Centre d’administration de Microsoft Entra au minimum en tant qu’Administrateur d’application cloud.
2. Accédez à Entra ID>Accès conditionnel>Politiques.
3. Sélectionnez la stratégie d’accès conditionnel qui exige une authentification MFA.
4. Sélectionnez Utilisateurs ou identités de charge de travail.
5. Sélectionnez l’onglet Exclure, puis cochez la case Utilisateurs et groupes.
6. Sélectionnez le compte d’utilisateur à exclure dans Sélectionner les utilisateurs exclus.
7. Sélectionnez le bouton Sélectionner, puis Enregistrer.

Pour exclure une application de test :

1. Dans Stratégies, sélectionnez la stratégie d’accès conditionnel qui exige une authentification MFA.
2. Sélectionnez Applications ou actions cloud.
3. Sélectionnez l’onglet Exclure, puis cochez Sélectionner les applications cloud exclues.
4. Sélectionnez les applications à exclure dans Sélectionner les applications cloud exclues.
5. Sélectionnez le bouton Sélectionner, puis Enregistrer.

Écrire vos tests d’application

Maintenant que vous êtes prêt, vous pouvez écrire vos tests automatisés. Les éléments suivants sont des tests pour :

1. L’exemple de code .NET utilise la Bibliothèque d’authentification Microsoft (MSAL) et xUnit, une infrastructure de test courante.
2. L’exemple de code JavaScript suivant utilise la Bibliothèque d’authentification Microsoft (MSAL) et Playwright, une infrastructure de test courante.

{
  "Authentication": {
    "AzureCloudInstance": "AzurePublic", //Will be different for different Azure clouds, like US Gov
    "AadAuthorityAudience": "AzureAdMultipleOrgs",
    "ClientId": <your_client_ID>
  },

  "WebAPI": {
    "Scopes": [
      //For this Microsoft Graph example.  Your value(s) will be different depending on the API you're calling
      "https://graph.microsoft.com/User.Read",
      //For this Microsoft Graph example.  Your value(s) will be different depending on the API you're calling
      "https://graph.microsoft.com/User.ReadBasic.All"
    ]
  },

  "KeyVault": {
    "KeyVaultUri": "https://<your-unique-keyvault-name>.vault.azure.net//"
  }
}

using Xunit;
using System.Threading.Tasks;
using Microsoft.Identity.Client;
using System.Security;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using Microsoft.Extensions.Configuration;
using Azure.Identity;
using Azure.Security.KeyVault.Secrets;
using Azure.Core;
using System;

public class ClientFixture : IAsyncLifetime
{
    public HttpClient httpClient;

    public async Task InitializeAsync()
    {
        var builder = new ConfigurationBuilder().AddJsonFile("<path-to-json-file>");

        IConfigurationRoot Configuration = builder.Build();

        var PublicClientApplicationOptions = new PublicClientApplicationOptions();
        Configuration.Bind("Authentication", PublicClientApplicationOptions);
        var app = PublicClientApplicationBuilder.CreateWithApplicationOptions(PublicClientApplicationOptions)
            .Build();

        SecretClientOptions options = new SecretClientOptions()
        {
            Retry =
                {
                    Delay= TimeSpan.FromSeconds(2),
                    MaxDelay = TimeSpan.FromSeconds(16),
                    MaxRetries = 5,
                    Mode = RetryMode.Exponential
                 }
        };

        string keyVaultUri = Configuration.GetValue<string>("KeyVault:KeyVaultUri");
        var client = new SecretClient(new Uri(keyVaultUri), new DefaultAzureCredential(), options);

        KeyVaultSecret userNameSecret = client.GetSecret("TestUserName");
        KeyVaultSecret passwordSecret = client.GetSecret("TestPassword");

        string password = passwordSecret.Value;
        string username = userNameSecret.Value;
        string[] scopes = Configuration.GetSection("WebAPI:Scopes").Get<string[]>();
        SecureString securePassword = new NetworkCredential("", password).SecurePassword;

        AuthenticationResult result = null;
        httpClient = new HttpClient();

        try
        {
            result = await app.AcquireTokenByUsernamePassword(scopes, username, securePassword)
                .ExecuteAsync();
        }
        catch (MsalException) { }

        string accessToken = result.AccessToken;
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", accessToken);
    }

    public Task DisposeAsync() => Task.CompletedTask;
}

public class ApiTests : IClassFixture<ClientFixture>
{
    ClientFixture clientFixture;

    public ApiTests(ClientFixture clientFixture)
    {
        this.clientFixture = clientFixture;
    }

    [Fact]
    public async Task GetRequestTest()
    {
        var testClient = clientFixture.httpClient;
        HttpResponseMessage response = await testClient.GetAsync("https://graph.microsoft.com/v1.0/me");
        var responseCode = response.StatusCode.ToString();
        Assert.Equal("OK", responseCode);
    }
}

export const msalConfig = {
    auth: {
        clientId: 'Enter_the_Application_Id_Here',
        authority: 'https://login.microsoftonline.com/Enter_the_Tenant_Id_Here',
    },
};

export const keyVaultConfig = {
    keyVaultUri: 'https://<your-unique-keyvault-name>.vault.azure.net',
    secretName: 'Enter_the_Secret_Name',
};

import { test, expect } from '@playwright/test';
import { DefaultAzureCredential } from '@azure/identity';
import { SecretClient } from '@azure/keyvault-secrets';
import { PublicClientApplication, CacheKVStore } from '@azure/msal-node';
import { msalConfig, keyVaultConfig } from '../authConfig';

let tokenCache;
const KVUri = keyVaultConfig.keyVaultUri;
const secretName = keyVaultConfig.secretName;

async function getCredentials() {
    try {
        const credential = new DefaultAzureCredential();
        const secretClient = new SecretClient(KVUri, credential);
        const secret = await secretClient.getSecret(keyVaultConfig.secretName);
        const password = secret.value;
        return [secretName, password];
    } catch (error) {
        console.log(error);
    }
}

test.beforeAll(async () => {
    const pca = new PublicClientApplication(msalConfig);
    const [username, password] = await getCredentials();
    const usernamePasswordRequest = {
        scopes: ['user.read', 'User.ReadBasic.All'],
        username: username,
        password: password,
    };
    await pca.acquireTokenByUsernamePassword(usernamePasswordRequest);
    tokenCache = pca.getTokenCache().getKVStore();
});

/**
 * Stores the token in the session storage and reloads the page
 */
async function setSessionStorage(page, tokens) {
    const cacheKeys = Object.keys(tokens);
    for (let key of cacheKeys) {
        const value = JSON.stringify(tokenCache[key]);
        await page.context().addInitScript(
            (arr) => {
                window.sessionStorage.setItem(arr[0], arr[1]);
            },
            [key, value]
        );
    }
    await page.reload();
}

test.describe('Testing Authentication with MSAL.js ', () => {
    test('Test user has signed in successfully', async ({ page }) => {
        await page.goto('http://localhost:<port>/');
        let signInButton = page.getByRole('button', { name: /Sign In/i });
        let signOutButton = page.getByRole('button', { name: /Sign Out/i });
        let welcomeDev = page.getByTestId('WelcomeMessage');
        expect(await signInButton.count()).toBeGreaterThan(0);
        expect(await signOutButton.count()).toBeLessThanOrEqual(0);
        expect(await welcomeDev.innerHTML()).toEqual('Please sign-in to see your profile and read your mails');
        await setSessionStorage(page, tokenCache);
        expect(await signInButton.count()).toBeLessThanOrEqual(0);
        expect(await signOutButton.count()).toBeGreaterThan(0);
        expect(await welcomeDev.innerHTML()).toContain(`Welcome`);
    });
});