Köra automatiserade integreringstester

Som utvecklare vill du köra automatiserade integreringstester på de appar som du utvecklar. Det är en utmaning att anropa ditt API som skyddas av Microsofts identitetsplattform (eller andra skyddade API:er som Microsoft Graph) i automatiserade integreringstester. Microsoft Entra-ID kräver ofta en interaktiv användarinloggningsprompt, vilket är svårt att automatisera. Den här artikeln beskriver hur du kan använda ett icke-interaktivt flöde, kallat Resource Owner Password Credential Grant (ROPC) för att automatiskt logga in användare för testning.

För att förbereda dig för dina automatiserade integreringstester skapar du några testanvändare, skapar och konfigurerar en appregistrering och kan eventuellt göra vissa konfigurationsändringar i klientorganisationen. Vissa av de här stegen kräver administratörsbehörighet. Dessutom rekommenderar Microsoft att du inte använder ROPC-flödet i en produktionsmiljö. Skapa en separat testklient som du är administratör för så att du på ett säkert och effektivt sätt kan köra dina automatiserade integreringstester.

Varning

Microsoft rekommenderar att du inte använder ROPC-flödet i en produktionsmiljö. I de flesta produktionsscenarier är säkrare alternativ tillgängliga och rekommenderas. ROPC-flödet kräver en mycket hög grad av förtroende för programmet och medför risker som inte finns i andra autentiseringsflöden. Du bör endast använda det här flödet i testsyfte i en separat testklientorganisation och endast med testanvändare.

Viktigt!

• Microsofts identitetsplattform stöder endast ROPC i Microsoft Entra-klientorganisationer, inte personliga konton. Det innebär att du måste använda en klientspecifik slutpunkt (https://login.microsoftonline.com/{TenantId_or_Name}) eller organizations slutpunkten.
• Personliga konton som bjuds in till en Microsoft Entra-klientorganisation kan inte använda ROPC.
• Konton som inte har lösenord kan inte logga in med ROPC, vilket innebär att funktioner som SMS-inloggning, FIDO och Authenticator-appen inte fungerar med det flödet.
• Om användarna behöver använda multifaktorautentisering (MFA) för att logga in i programmet blockeras de i stället.
• ROPC stöds inte i hybrididentitetsfederationsscenarier (till exempel Microsoft Entra ID och Active Directory Federation Services (AD FS) (AD FS) som används för att autentisera lokala konton). Om användarna omdirigeras till en lokal identitetsprovider kan Microsoft Entra ID inte testa användarnamnet och lösenordet mot identitetsprovidern. Direktautentisering stöds dock med ROPC.
• Ett undantag till ett hybrididentitetsfederationsscenario skulle vara följande: Principen För identifiering av hemsfär med AllowCloudPasswordValidation inställd på TRUE gör det möjligt för ROPC-flödet att fungera för federerade användare när lokala lösenord synkroniseras till molnet. Mer information finns i Aktivera direkt ROPC-autentisering för federerade användare för äldre program.

Skapa en separat testklient

Det är riskabelt att använda ROPC-autentiseringsflödet i en produktionsmiljö, så skapa en separat klientorganisation för att testa dina program. Du kan använda en befintlig testklient, men du måste vara administratör i klientorganisationen eftersom vissa av följande steg kräver administratörsbehörighet.

Skapa och konfigurera ett nyckelvalv

Vi rekommenderar att du lagrar testanvändarna och lösenorden på ett säkert sätt som hemligheter i Azure Key Vault. När du kör testerna senare körs testerna i kontexten för ett säkerhetsobjekt. Säkerhetsobjektet är en Microsoft Entra-användare om du kör tester lokalt (till exempel i Visual Studio eller Visual Studio Code) eller ett huvudnamn för tjänsten eller en hanterad identitet om du kör tester i Azure Pipelines eller en annan Azure-resurs. Säkerhetsobjektet måste ha behörigheter för läs - och listhemligheter så att testkörarna kan hämta testanvändarnamn och lösenord från nyckelvalvet. Mer information finns i Autentisering i Azure Key Vault.

1. Skapa ett nytt nyckelvalv om du inte redan har ett.
2. Anteckna egenskapsvärdet för Vault URI (liknar https://<your-unique-keyvault-name>.vault.azure.net/) som används i exempeltestet senare i den här artikeln.
3. Tilldela en åtkomstprincip för säkerhetsobjektet som kör testerna. Bevilja behörigheter för användaren, tjänstens huvudnamn eller hanterade identitet hämta och lista hemligheter i nyckelvalvet.

Skapa testanvändare

Dricks

Stegen i den här artikeln kan variera något beroende på vilken portal du börjar från.

Skapa några testanvändare i klientorganisationen för testning. Eftersom testanvändarna inte är verkliga människor rekommenderar vi att du tilldelar komplexa lösenord och lagrar dessa lösenord på ett säkert sätt som hemligheter i Azure Key Vault.

1. Logga in på administrationscentret för Microsoft Entra som minst molnprogramadministratör.
2. Bläddra till Identitetsanvändare>>Alla användare.
3. Välj Ny användare och skapa ett eller flera testanvändarkonton i din katalog.
4. Exempeltestet senare i den här artikeln använder en enskild testanvändare. Lägg till testanvändarnamnet och lösenordet som hemligheter i nyckelvalvet som du skapade tidigare. Lägg till användarnamnet som en hemlighet med namnet "TestUserName" och lösenordet som en hemlighet med namnet "TestPassword".

Skapa och konfigurera en appregistrering

Registrera ett program som fungerar som din klientapp när du anropar API:er under testningen. Detta bör inte vara samma program som du kanske redan har i produktion. Du bör ha en separat app som endast ska användas i testsyfte.

Registrera en app

Skapa en appregistrering. Du kan följa stegen i snabbstarten för appregistrering. Du behöver inte lägga till en omdirigerings-URI eller lägga till autentiseringsuppgifter, så du kan hoppa över dessa avsnitt.

Anteckna program-ID:t (klient), som används i exempeltestet senare i den här artikeln.

Aktivera din app för offentliga klientflöden

ROPC är ett offentligt klientflöde, så du måste aktivera appen för offentliga klientflöden. Från appregistreringen i administrationscentret för Microsoft Entra går du till Avancerade inställningar>för autentisering>Tillåt offentliga klientflöden. Ange växlingsknappen till Ja.

Samtyck till de behörigheter som du vill använda vid testning

Eftersom ROPC inte är ett interaktivt flöde uppmanas du inte med en medgivandeskärm att godkänna dessa vid körning. Förhandsmedgivande till behörigheterna för att undvika fel vid anskaffning av token.

Lägg till behörigheterna i din app. Lägg inte till några känsliga behörigheter eller behörigheter med hög behörighet i appen. Vi rekommenderar att du omfångsbegränsar dina testscenarier till grundläggande integreringsscenarier kring integrering med Microsoft Entra-ID.

Från appregistreringen i administrationscentret för Microsoft Entra går du till API-behörigheter>Lägg till en behörighet. Lägg till de behörigheter som du behöver för att anropa de API:er som du ska använda. Ett testexempel längre fram i den här artikeln använder behörigheterna https://graph.microsoft.com/User.Read och https://graph.microsoft.com/User.ReadBasic.All .

När behörigheterna har lagts till måste du godkänna dem. Hur du godkänner behörigheterna beror på om testappen finns i samma klientorganisation som appregistreringen och om du är administratör i klientorganisationen.

App- och appregistrering finns i samma klientorganisation och du är administratör

Om du planerar att testa appen i samma klientorganisation som du har registrerat den i och du är administratör i den klientorganisationen kan du godkänna behörigheterna från administrationscentret för Microsoft Entra. I din appregistrering i Azure-portalen går du till API-behörigheter och väljer knappen Bevilja administratörsmedgivande för <your_tenant_name> bredvid knappen Lägg till en behörighet och sedan Ja för att bekräfta.

App- och appregistrering finns i olika klientorganisationer, eller så är du inte administratör

Om du inte planerar att testa din app i samma klientorganisation som du har registrerat den i, eller om du inte är administratör i din klientorganisation, kan du inte godkänna behörigheterna från administrationscentret för Microsoft Entra. Du kan dock fortfarande godkänna vissa behörigheter genom att utlösa en inloggningsprompt i en webbläsare.

I din appregistrering i administrationscentret för Microsoft Entra går du till Konfigurationer för autentiseringsplattform>>Lägg till en plattformswebb.> Lägg till omdirigerings-URI:n "https://localhost" och välj Konfigurera.

Det finns inget sätt för icke-administratörsanvändare att i förväg godkänna via Azure-portalen, så skicka följande begäran i en webbläsare. När du uppmanas att använda inloggningsskärmen loggar du in med ett testkonto som du skapade i ett tidigare steg. Samtyck till de behörigheter som du uppmanas att ge. Du kan behöva upprepa det här steget för varje API som du vill anropa och testa användare som du vill använda.

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

Ersätt {tenant} med ditt klient-ID, {your_client_ID} med programmets klient-ID och {resource_you_want_to_call} med identifierar-URI:n (till exempel "https://graph.microsoft.com") eller app-ID för det API som du försöker komma åt.

Undanta testappar och användare från din MFA-princip

Din klientorganisation har troligen en princip för villkorsstyrd åtkomst som kräver multifaktorautentisering (MFA) för alla användare, vilket rekommenderas av Microsoft. MFA fungerar inte med ROPC, så du måste undanta dina testprogram och testanvändare från det här kravet.

Så här exkluderar du användarkonton:

1. Logga in på administrationscentret för Microsoft Entra som minst molnprogramadministratör.
2. Bläddra till Identity>Security Center i det vänstra navigeringsfönstret och välj sedan Villkorlig åtkomst.
3. I Principer väljer du den princip för villkorsstyrd åtkomst som kräver MFA.
4. Välj Användare eller arbetsbelastningsidentiteter.
5. Markera fliken Exkludera och sedan kryssrutan Användare och grupper.
6. Välj de användarkonton som ska undantas i Välj exkluderade användare.
7. Välj knappen Välj och sedan Spara.

Så här exkluderar du ett testprogram:

1. I Principer väljer du den princip för villkorsstyrd åtkomst som kräver MFA.
2. Välj Molnappar eller åtgärder.
3. Välj fliken Exkludera och sedan Välj exkluderade molnappar.
4. Välj de appar som du vill exkludera i Välj exkluderade molnappar.
5. Välj knappen Välj och sedan Spara.

Skriva dina programtester

Nu när du har konfigurerats kan du skriva dina automatiserade tester. Följande är tester för:

1. .NET-exempelkoden använder Microsoft Authentication Library (MSAL) och xUnit, ett gemensamt testramverk.
2. JavaScript-exempelkoden använder Microsoft Authentication Library (MSAL) och Playwright, ett gemensamt testramverk.

.NET

Konfigurera filen appsettings.json

Lägg till klient-ID:t för testappen som du skapade tidigare, de nödvändiga omfången och nyckelvalvs-URI:n i filen appsettings.json i testprojektet.

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

Konfigurera klienten för användning i alla testklasser

Använd SecretClient() för att hämta testhemligheterna för användarnamn och lösenord från Azure Key Vault. Koden använder exponentiell säkerhetskopiering för återförsök om Key Vault begränsas.

DefaultAzureCredential() autentiserar med Azure Key Vault genom att hämta en åtkomsttoken från ett tjänsthuvudnamn som konfigurerats av miljövariabler eller en hanterad identitet (om koden körs på en Azure-resurs med en hanterad identitet). Om koden körs lokalt DefaultAzureCredential använder du den lokala användarens autentiseringsuppgifter. Läs mer i innehållet i Azure Identity-klientbiblioteket .

Använd Microsoft Authentication Library (MSAL) för att autentisera med ropc-flödet och hämta en åtkomsttoken. Åtkomsttoken skickas som en ägartoken i HTTP-begäran.

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

Använda i dina testklasser

Följande exempel är ett test som anropar Microsoft Graph. Ersätt det här testet med det du vill testa i ditt eget program eller 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

Konfigurera filen authConfig.json

Lägg till klient-ID:t och klient-ID:t för testappen som du skapade tidigare, nyckelvalvs-URI:n och det hemliga namnet i filen authConfig.js i testprojektet.

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

Initiera MSAL.js och hämta användarautentiseringsuppgifterna från Key Vault

Initiera MSAL.js-autentiseringskontexten genom att instansiera en PublicClientApplication med ett konfigurationsobjekt . Den minsta nödvändiga konfigurationsegenskapen clientID är programmets.

Använd SecretClient() för att hämta testhemligheterna för användarnamn och lösenord från Azure Key Vault.

DefaultAzureCredential() autentiserar med Azure Key Vault genom att hämta en åtkomsttoken från ett tjänsthuvudnamn som konfigurerats av miljövariabler eller en hanterad identitet (om koden körs på en Azure-resurs med en hanterad identitet). Om koden körs lokalt DefaultAzureCredential använder du den lokala användarens autentiseringsuppgifter. Läs mer i innehållet i Azure Identity-klientbiblioteket .

Använd Microsoft Authentication Library (MSAL) för att autentisera med ropc-flödet och hämta en åtkomsttoken. Åtkomsttoken skickas som en ägartoken i HTTP-begäran.

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

Kör testpaketet

I samma fil lägger du till testerna enligt nedan:

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

Mer information finns i följande exempel på msal.js-testexempel.