Geautomatiseerde integratietests uitvoeren

Als ontwikkelaar wilt u geautomatiseerde integratietests uitvoeren op de apps die u ontwikkelt. Het aanroepen van uw API die wordt beveiligd door het Microsoft Identity Platform (of andere beveiligde API's zoals Microsoft Graph) in geautomatiseerde integratietests is een uitdaging. Microsoft Entra ID vereist vaak een interactieve aanmeldingsprompt van gebruikers. Dit is moeilijk te automatiseren. In dit artikel wordt beschreven hoe u een niet-interactieve stroom, genaamd Resource Owner Password Credential Grant (ROPC), kunt gebruiken om gebruikers automatisch aan te melden voor testen.

Als u zich wilt voorbereiden op uw geautomatiseerde integratietests, maakt u enkele testgebruikers, maakt en configureert u een app-registratie en kunt u mogelijk enkele configuratiewijzigingen aanbrengen in uw tenant. Voor sommige van deze stappen zijn beheerdersbevoegdheden vereist. Bovendien raadt Microsoft u aan de ROPC-stroom niet te gebruiken in een productieomgeving. Maak een afzonderlijke testtenant waarvan u beheerder bent, zodat u uw geautomatiseerde integratietests veilig en effectief kunt uitvoeren.

Waarschuwing

Microsoft raadt u aan de ROPC-stroom niet te gebruiken in een productieomgeving. In de meeste productiescenario's zijn veiligere alternatieven beschikbaar en aanbevolen. De ROPC-stroom vereist een zeer hoge mate van vertrouwen in de toepassing en draagt risico's die niet aanwezig zijn in andere verificatiestromen. U moet deze stroom alleen gebruiken voor testdoeleinden in een afzonderlijke testtenant en alleen voor testgebruikers.

Belangrijk

• Het Microsoft Identity Platform biedt alleen ondersteuning voor ROPC binnen Microsoft Entra-tenants, niet voor persoonlijke accounts. Dit betekent dat u een tenant-specifiek eindpunt moet gebruiken (https://login.microsoftonline.com/{TenantId_or_Name}) of het eindpunt van organizations.
• Persoonlijke accounts die voor een Microsoft Entra-tenant zijn uitgenodigd, kunnen ROPC niet gebruiken.
• Accounts die geen wachtwoorden hebben, kunnen zich niet aanmelden met ROPC. Dit betekent dat functies zoals sms-aanmelding, FIDO en de Authenticator-app niet met die stroom werken.
• Als gebruikers meervoudige verificatie (MFA) moeten gebruiken om zich aan te melden bij de toepassing, worden ze geblokkeerd.
• ROPC wordt niet ondersteund in hybride identiteitsfederatiescenario's (bijvoorbeeld Microsoft Entra ID en Active Directory Federation Services (AD FS) die worden gebruikt om on-premises accounts te verifiëren. Als gebruikers op de volledige pagina worden omgeleid naar een on-premises id-provider, kan Microsoft Entra ID de gebruikersnaam en het wachtwoord niet testen op basis van die id-provider. Passthrough-verificatie wordt echter wel ondersteund met ROPC.
• Een uitzondering op een hybride identiteitsfederatiescenario is het volgende: Home Realm Discovery-beleid waarbij AllowCloudPasswordValidation is ingesteld op TRUE, zorgt ervoor dat ROPC-stroom werkt voor federatieve gebruikers wanneer een on-premises wachtwoord wordt gesynchroniseerd met de cloud. Zie Directe ROPC-verificatie van gefedereerde gebruikers inschakelen voor oude toepassingen voor meer informatie.

Een afzonderlijke testtenant maken

Het gebruik van de ROPC-verificatiestroom is riskant in een productieomgeving, dus maak een afzonderlijke tenant om uw toepassingen te testen. U kunt een bestaande testtenant gebruiken, maar u moet een beheerder in de tenant zijn, omdat voor sommige van de volgende stappen beheerdersbevoegdheden zijn vereist.

Een sleutelkluis maken en configureren

U wordt aangeraden de testgebruikersnamen en wachtwoorden veilig op te slaan als geheimen in Azure Key Vault. Wanneer u de tests later uitvoert, worden de tests uitgevoerd in de context van een beveiligingsprincipaal. De beveiligingsprincipaal is een Microsoft Entra-gebruiker als u lokaal tests uitvoert (bijvoorbeeld in Visual Studio of Visual Studio Code), of een service-principal of beheerde identiteit als u tests uitvoert in Azure Pipelines of een andere Azure-resource. De beveiligingsprincipaal moet lees- en lijstgeheimmachtigingen hebben, zodat de testloper de testgebruikersnamen en wachtwoorden uit uw sleutelkluis kan ophalen. Lees verificatie in Azure Key Vault voor meer informatie.

1. Maak een nieuwe sleutelkluis als u er nog geen hebt.
2. Noteer de waarde van de kluis-URI-eigenschap (vergelijkbaar met https://<your-unique-keyvault-name>.vault.azure.net/) die wordt gebruikt in de voorbeeldtest verderop in dit artikel.
3. Wijs een toegangsbeleid toe voor de beveiligingsprincipaal die de tests uitvoert. Ververleent de gebruiker, service-principal of beheerde identiteit geheimenmachtigingen ophalen en weergeven in de sleutelkluis.

Testgebruikers maken

Tip

Stappen in dit artikel kunnen enigszins variëren op basis van de portal waaruit u begint.

Maak enkele testgebruikers in uw tenant om te testen. Omdat de testgebruikers geen echte mensen zijn, raden we u aan complexe wachtwoorden toe te wijzen en deze wachtwoorden veilig op te slaan als geheimen in Azure Key Vault.

1. Meld u als cloudtoepassingsbeheerder aan bij het Microsoft Entra-beheercentrum.
2. Blader naar Identiteit>Gebruikers>Alle gebruikers.
3. Selecteer Nieuwe gebruiker en maak een of meer testgebruikersaccounts in uw directory.
4. De voorbeeldtest verderop in dit artikel maakt gebruik van één testgebruiker. Voeg de testnaam en het wachtwoord toe als geheimen in de sleutelkluis die u eerder hebt gemaakt. Voeg de gebruikersnaam toe als een geheim met de naam TestUserName en het wachtwoord als een geheim met de naam TestPassword.

Een app-registratie maken en configureren

Registreer een toepassing die fungeert als uw client-app bij het aanroepen van API's tijdens het testen. Dit mag niet dezelfde toepassing zijn die u mogelijk al in productie hebt. U moet een afzonderlijke app hebben die alleen moet worden gebruikt voor testdoeleinden.

Een toepassing registreren

Maak een app-registratie. U kunt de stappen in de quickstart voor app-registratie volgen. U hoeft geen omleidings-URI toe te voegen of referenties toe te voegen, zodat u deze secties kunt overslaan.

Noteer de toepassings-id (client), die wordt gebruikt in de voorbeeldtest verderop in dit artikel.

Uw app inschakelen voor openbare clientstromen

ROPC is een openbare clientstroom, dus u moet uw app inschakelen voor openbare clientstromen. Ga vanuit uw app-registratie in het Microsoft Entra-beheercentrum naar> Geavanceerde verificatie-instellingen>: openbare clientstromen toestaan. Stel de wisselknop in op Ja.

Toestemming geven voor de machtigingen die u wilt gebruiken tijdens het testen

Omdat ROPC geen interactieve stroom is, wordt u niet gevraagd om toestemming te geven tijdens runtime. Geef vooraf toestemming voor de machtigingen om fouten te voorkomen bij het verkrijgen van tokens.

Voeg de machtigingen toe aan uw app. Voeg geen gevoelige of uitgebreide machtigingen toe aan de app. We raden u aan uw testscenario's te beperken tot basisintegratiescenario's voor integratie met Microsoft Entra ID.

Ga vanuit uw app-registratie in het Microsoft Entra-beheercentrum naar API-machtigingen>een machtiging toevoegen. Voeg de machtigingen toe die u nodig hebt om de API's aan te roepen die u gaat gebruiken. In een testvoorbeeld verder in dit artikel worden de https://graph.microsoft.com/User.Read en https://graph.microsoft.com/User.ReadBasic.All machtigingen gebruikt.

Zodra de machtigingen zijn toegevoegd, moet u er toestemming voor geven. De manier waarop u toestemming geeft voor de machtigingen, is afhankelijk van of uw test-app zich in dezelfde tenant bevindt als de app-registratie en of u een beheerder in de tenant bent.

App- en app-registratie bevinden zich in dezelfde tenant en u bent een beheerder

Als u van plan bent om uw app te testen in dezelfde tenant waarin u deze hebt geregistreerd en u een beheerder bent in die tenant, kunt u toestemming geven voor de machtigingen van het Microsoft Entra-beheercentrum. Ga in uw app-registratie in Azure Portal naar API-machtigingen en selecteer de knop Beheerderstoestemming verlenen voor <your_tenant_name> knop naast de knop Een machtiging toevoegen en vervolgens Ja om te bevestigen.

App- en app-registratie bevinden zich in verschillende tenants of u bent geen beheerder

Als u niet van plan bent om uw app te testen in dezelfde tenant waarin u deze hebt geregistreerd of als u geen beheerder bent in uw tenant, kunt u geen toestemming geven voor de machtigingen van het Microsoft Entra-beheercentrum. U kunt echter nog steeds toestemming geven voor bepaalde machtigingen door een aanmeldingsprompt in een webbrowser te activeren.

Ga in uw app-registratie in het Microsoft Entra-beheercentrum naar verificatieplatformconfiguraties>>: een platformweb> toevoegen. Voeg de omleidings-URI toe "https://localhost" en selecteer Configureren.

Er is geen manier om niet-beheerders vooraf toestemming te geven via Azure Portal. Verzend daarom de volgende aanvraag in een browser. Wanneer u wordt gevraagd om het aanmeldingsscherm, meldt u zich aan met een testaccount dat u in een vorige stap hebt gemaakt. Geef toestemming voor de machtigingen waarmee u wordt gevraagd. Mogelijk moet u deze stap herhalen voor elke API die u wilt aanroepen en testen.

// 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

Vervang {tenant} door uw tenant-id, {your_client_ID} door de client-id van uw toepassing en {resource_you_want_to_call} door de id-URI (bijvoorbeeld 'https://graph.microsoft.com") of app-id van de API die u probeert te openen.

Test-apps en -gebruikers uitsluiten van uw MFA-beleid

Uw tenant heeft waarschijnlijk een beleid voor voorwaardelijke toegang waarvoor meervoudige verificatie (MFA) is vereist voor alle gebruikers, zoals wordt aanbevolen door Microsoft. MFA werkt niet met ROPC, dus u moet uw testtoepassingen uitsluiten en gebruikers testen op basis van deze vereiste.

Gebruikersaccounts uitsluiten:

1. Meld u als cloudtoepassingsbeheerder aan bij het Microsoft Entra-beheercentrum.
2. Blader naar Identity>Security Center in het linkernavigatiedeelvenster en selecteer vervolgens Voorwaardelijke toegang.
3. Selecteer in Beleid het beleid voor voorwaardelijke toegang waarvoor MFA is vereist.
4. Selecteer Gebruikers- of workloadidentiteiten.
5. Schakel het tabblad Uitsluiten in en schakel vervolgens het selectievakje Gebruikers en groepen in.
6. Selecteer de gebruikersaccounts die u wilt uitsluiten in Uitgesloten gebruikers selecteren.
7. Selecteer de knop Selecteren en vervolgens Opslaan.

Een testtoepassing uitsluiten:

1. Selecteer in Beleid het beleid voor voorwaardelijke toegang waarvoor MFA is vereist.
2. Selecteer Cloud-apps of -acties.
3. Selecteer het tabblad Uitsluiten en selecteer vervolgens uitgesloten cloud-apps.
4. Selecteer de apps die u wilt uitsluiten in uitgesloten cloud-apps.
5. Selecteer de knop Selecteren en vervolgens Opslaan.

Uw toepassingstests schrijven

Nu u klaar bent, kunt u uw geautomatiseerde tests schrijven. Hier volgen tests voor:

1. .NET-voorbeeldcode maakt gebruik van Microsoft Authentication Library (MSAL) en xUnit, een algemeen testframework.
2. JavaScript-voorbeeldcode maakt gebruik van Microsoft Authentication Library (MSAL) en Playwright, een algemeen testframework.

.NET

Uw appsettings.json-bestand instellen

Voeg de client-id toe van de test-app die u eerder hebt gemaakt, de benodigde bereiken en de sleutelkluis-URI aan het appsettings.json-bestand van uw testproject.

{
  "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//"
  }
}

Uw client instellen voor gebruik in al uw testklassen

Gebruik SecretClient() om de gebruikersnaam en het wachtwoord van de test op te halen uit Azure Key Vault. De code maakt gebruik van exponentiële back-off voor nieuwe pogingen voor het geval Key Vault wordt beperkt.

DefaultAzureCredential() wordt geverifieerd met Azure Key Vault door een toegangstoken op te halen van een service-principal die is geconfigureerd door omgevingsvariabelen of een beheerde identiteit (als de code wordt uitgevoerd op een Azure-resource met een beheerde identiteit). Als de code lokaal wordt uitgevoerd, DefaultAzureCredential gebruikt u de referenties van de lokale gebruiker. Lees meer in de inhoud van de Azure Identity-clientbibliotheek .

Gebruik Microsoft Authentication Library (MSAL) om te verifiëren met behulp van de ROPC-stroom en een toegangstoken op te halen. Het toegangstoken wordt doorgegeven als een bearer-token in de HTTP-aanvraag.

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

Gebruiken in uw testklassen

Het volgende voorbeeld is een test die Microsoft Graph aanroept. Vervang deze test door wat u ook wilt testen op uw eigen toepassing of API.

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

JavaScript

Uw authConfig.json-bestand instellen

Voeg de client-id en de tenant-id van de test-app die u eerder hebt gemaakt, de sleutelkluis-URI en de geheime naam toe aan het authConfig.js-bestand van uw testproject.

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',
};

Initialiseer MSAL.js en haal de gebruikersreferenties op uit Key Vault

Initialiseer de verificatiecontext van de MSAL.js door een PublicClientApplication te instantiëren met een configuratieobject. De minimaal vereiste configuratie-eigenschap is de clientID toepassing.

Gebruik SecretClient() om de gebruikersnaam en het wachtwoord van de test op te halen uit Azure Key Vault.

DefaultAzureCredential() wordt geverifieerd met Azure Key Vault door een toegangstoken op te halen van een service-principal die is geconfigureerd door omgevingsvariabelen of een beheerde identiteit (als de code wordt uitgevoerd op een Azure-resource met een beheerde identiteit). Als de code lokaal wordt uitgevoerd, DefaultAzureCredential gebruikt u de referenties van de lokale gebruiker. Lees meer in de inhoud van de Azure Identity-clientbibliotheek .

Gebruik Microsoft Authentication Library (MSAL) om te verifiëren met behulp van de ROPC-stroom en een toegangstoken op te halen. Het toegangstoken wordt doorgegeven als een bearer-token in de HTTP-aanvraag.

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

De testsuite uitvoeren

Voeg in hetzelfde bestand de tests toe zoals hieronder wordt weergegeven:

/**
 * 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`);
    });
});

Raadpleeg het volgende codevoorbeeld MSAL.js Testvoorbeeld voor meer informatie.