Test des exceptions de serveur

Aperçu

Le serveur de test PlayReady inclut des fonctionnalités spéciales pour déclencher par programme différentes exceptions de serveur. Cette fonctionnalité permet aux développeurs clients de tester la façon dont leurs appareils et applications répondent à différentes conditions d’erreur qui peuvent se produire lors de l’acquisition de licences dans des environnements de production.

Test des exceptions de serveur

Les développeurs clients peuvent utiliser ces commandes d’exception de serveur pour valider la gestion des erreurs dans leurs implémentations. Cela inclut des scénarios de test tels que la révocation d’appareils, les erreurs de serveur interne, les incompatibilités de protocole et les exceptions liées au domaine.

Exemple de transaction

Voici un exemple de fonctionnement des exceptions de serveur :

URL de la demande :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c065)

Réponse du serveur :

HTTP/1.1 500 Internal Server Error
Cache-Control: private
Content-Length: 764
Content-Type: text/xml; charset=utf-8

<?xml version="1.0" encoding="utf-8" ?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" 
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <soap:Body>
        <soap:Fault>
            <faultcode>soap:Server</faultcode>
            <faultstring>
                System.Web.Services.Protocols.SoapException: Device Certificate Revoked.
                at Microsoft.Media.Drm.RightsManager.ConvertRmServerException(RMServerException ex)
                at Microsoft.Media.Drm.RightsManager.AcquireLicense(XmlDocument challenge)
            </faultstring>
            <faultactor>http://prtsprod-rightsmanager.azurewebsites.net/rightsmanager.asmx?cfg=(errorcode:0x8004c065)</faultactor>
            <detail>
                <Exception>
                    <StatusCode>0x8004c065</StatusCode>
                </Exception>
            </detail>
        </soap:Fault>
    </soap:Body>
</soap:Envelope>

Paramètres d’exception

Paramètre d’exception générique

Exceptions d’appareil et de client

Certificat d’appareil révoqué

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c065)

Utilisation : testez la façon dont le client gère les scénarios de révocation d’appareils.

Exceptions internes du serveur

Erreur interne du serveur

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c600)

Utilisation : testez la résilience du client aux erreurs internes côté serveur.

Message non valide

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c601)

Utilisation : testez la gestion du client des réponses de requête incorrectes.

Incompatibilité de version du protocole

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c60b)

Utilisation : testez le comportement du client avec des versions de protocole non prises en charge.

Exception spécifique au service

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c604)

Utilisation : testez la gestion des clients des erreurs spécifiques au service.

Protocole et exceptions de redirection

Redirection de protocole

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c60d)

Utilisation : testez la gestion des clients des redirections de serveur.

exceptions Domain-Related

Domaine requis

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c605)

Utilisation : testez les scénarios de jonction de domaine et la sensibilisation au domaine client.

Renouveler le domaine

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c606)

Utilisation : testez les processus de renouvellement de certificat de domaine.

Limite d’appareil atteinte

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c602)

Utilisation : testez la gestion des clients des limites des appareils de domaine.

Non un membre de domaine

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c60a)

Utilisation : testez le comportement du client lorsqu’il est supprimé du domaine.

ID de compte inconnu

Exemple :

http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:0x8004c60c)

Utilisation : testez la gestion des clients des scénarios de compte de domaine inconnus.

Scénarios de test

Test d’exception de base

async function testServerExceptions() {
    const exceptions = [
        { name: 'Device Revoked', code: '0x8004c065' },
        { name: 'Internal Error', code: '0x8004c600' },
        { name: 'Invalid Message', code: '0x8004c601' },
        { name: 'Protocol Mismatch', code: '0x8004c60b' }
    ];
    
    const results = [];
    for (const exception of exceptions) {
        try {
            const url = `http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:${exception.code})`;
            const response = await testLicenseAcquisition(url);
            results.push({
                test: exception.name,
                result: 'UNEXPECTED_SUCCESS',
                error: 'Expected exception but got success'
            });
        } catch (error) {
            results.push({
                test: exception.name,
                result: 'EXPECTED_EXCEPTION',
                errorCode: error.statusCode,
                message: error.message
            });
        }
    }
    
    return results;
}

Test des exceptions de domaine

async function testDomainExceptions() {
    const domainExceptions = [
        { name: 'Domain Required', code: '0x8004c605' },
        { name: 'Renew Domain', code: '0x8004c606' },
        { name: 'Device Limit Reached', code: '0x8004c602' },
        { name: 'Not a Member', code: '0x8004c60a' },
        { name: 'Unknown Account', code: '0x8004c60c' }
    ];
    
    const results = [];
    for (const exception of domainExceptions) {
        try {
            const url = `http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:${exception.code})`;
            await testLicenseAcquisition(url);
            results.push({
                test: exception.name,
                result: 'FAIL',
                reason: 'Expected domain exception but got success'
            });
        } catch (error) {
            results.push({
                test: exception.name,
                result: 'PASS',
                exceptionType: exception.name,
                statusCode: error.statusCode
            });
        }
    }
    
    return results;
}

Test de robustesse du client

async function testClientRobustness() {
    // Test how client handles rapid exception scenarios
    const rapidTests = [
        '0x8004c065', // Device revoked
        '0x8004c600', // Internal error  
        '0x8004c601', // Invalid message
        '0x8004c60b'  // Protocol mismatch
    ];
    
    const startTime = Date.now();
    const promises = rapidTests.map(code => {
        const url = `http://test.playready.microsoft.com/service/rightsmanager.asmx?cfg=(errorcode:${code})`;
        return testLicenseAcquisitionWithTimeout(url, 5000);
    });
    
    const results = await Promise.allSettled(promises);
    const endTime = Date.now();
    
    return {
        totalTime: endTime - startTime,
        results: results.map((result, index) => ({
            errorCode: rapidTests[index],
            status: result.status,
            handled: result.status === 'rejected' // We expect rejections
        }))
    };
}

Instructions d’implémentation du client

Meilleures pratiques de gestion des exceptions

class PlayReadyExceptionHandler {
    handleLicenseAcquisitionError(error) {
        switch (error.statusCode) {
            case 0x8004C065: // Device revoked
                return this.handleDeviceRevoked();
                
            case 0x8004C600: // Internal server error
                return this.handleServerError(error);
                
            case 0x8004C601: // Invalid message
                return this.handleInvalidMessage(error);
                
            case 0x8004C60B: // Protocol version mismatch
                return this.handleProtocolMismatch(error);
                
            case 0x8004C605: // Domain required
                return this.handleDomainRequired(error);
                
            case 0x8004C606: // Renew domain
                return this.handleDomainRenewal(error);
                
            default:
                return this.handleUnknownError(error);
        }
    }
    
    handleDeviceRevoked() {
        // Device is revoked - cannot proceed
        throw new Error('Device has been revoked and cannot play protected content');
    }
    
    handleServerError(error) {
        // Retry with exponential backoff
        return this.retryWithBackoff(error.originalRequest);
    }
    
    handleDomainRequired(error) {
        // Initiate domain joining process
        return this.joinDomain(error.domainServiceUrl);
    }
    
    handleDomainRenewal(error) {
        // Renew domain certificate
        return this.renewDomainCertificate(error.domainServiceUrl);
    }
}

Gestion des exceptions C#

public class PlayReadyExceptionHandler
{
    public async Task<bool> HandleLicenseException(Exception ex)
    {
        if (ex is SoapException soapEx)
        {
            var statusCode = ExtractStatusCode(soapEx);
            
            switch (statusCode)
            {
                case 0x8004C065: // Device revoked
                    return HandleDeviceRevoked();
                    
                case 0x8004C600: // Internal server error
                    return await HandleServerError(soapEx);
                    
                case 0x8004C605: // Domain required
                    return await HandleDomainRequired(soapEx);
                    
                case 0x8004C606: // Renew domain
                    return await HandleDomainRenewal(soapEx);
                    
                default:
                    return HandleUnknownError(soapEx);
            }
        }
        
        return false;
    }
    
    private uint ExtractStatusCode(SoapException soapEx)
    {
        // Extract status code from SOAP fault detail
        var detail = soapEx.Detail;
        var statusNode = detail?.SelectSingleNode("//StatusCode");
        
        if (statusNode != null && uint.TryParse(statusNode.InnerText.Replace("0x", ""), 
            NumberStyles.HexNumber, null, out uint statusCode))
        {
            return statusCode;
        }
        
        return 0;
    }
}

Validation et test

Comportements attendus

Lors du test avec des exceptions de serveur, vérifiez que votre client :

1. Analyse correctement les exceptions : extrait correctement les codes d’erreur et les messages
2. Gère correctement : ne se bloque pas ou ne se bloque pas sur les exceptions
3. Fournit des commentaires sur l’utilisateur - Affiche les messages d’erreur appropriés aux utilisateurs
4. Implémente la logique de nouvelle tentative : nouvelles tentatives d’erreurs appropriées avec interruption
5. Prend en charge les opérations de domaine - Gère correctement les exceptions liées au domaine

Liste de contrôle de validation de test

• [ ] Le client identifie correctement les types d’exceptions
• [ ] Les messages utilisateur appropriés sont affichés
• [ ] Le client ne se bloque pas sur un type d’exception
• [ ] La logique de nouvelle tentative fonctionne pour les erreurs récupérables
• [ ] Les processus de jonction/renouvellement de domaine sont déclenchés correctement
• [ ] La révocation de l’appareil est gérée en toute sécurité
• [ ] Les performances restent acceptables dans les conditions d’erreur

Meilleures pratiques

Développement du client

1. Gestion complète des erreurs - Gérer tous les types d’exceptions documentés
2. Expérience utilisateur - Fournir des messages d’erreur clairs et actionnables
3. Stratégie de nouvelle tentative - Implémenter une logique de nouvelle tentative appropriée pour les erreurs temporaires
4. Sécurité - Vérifier que la révocation des appareils empêche l’accès au contenu
5. Test - Tester tous les scénarios d’exception pendant le développement

Récupération d’erreur

1. Dégradation appropriée - Continuer l’opération lorsque cela est possible
2. Communication claire - Informer les utilisateurs des problèmes et des solutions
3. Récupération automatique - Tentative de résolution automatique, le cas échéant
4. Options de secours - Fournir d’autres contenus ou services
5. Journalisation : exceptions de journalisation pour le débogage et l’analytique

Documentation connexe

• Service de serveur de test PlayReady - Fonctionnalité du serveur de test principal
• Syntaxe de chaîne de requête - Informations de référence sur la syntaxe des paramètres
• Test des protections de sortie - Test de la protection de sortie
• Serveurs de test PlayReady - Documentation complète sur le serveur

Ressources de support

Requêtes métier

• E-mail : playready@microsoft.com

Requêtes d’opérations

• Site web : http://wmlalicensing.com/
• E-mail : ipla@microsoft.com

Support technique

• Portail de support : Support technique PlayReady

Informations de formation

• E-mail : plyrdyev@microsoft.com

© Microsoft Corporation. Tous les droits réservés. Marques | Vie privée