Référence API C#

Classes C# d’Axe DevTools

Cette page documente les classes qui composent Axe DevTools C#

class Deque.AxeDevtools.Selenium.AxeSelenium

L'interface de l'analyse d'accessibilité. Contient des configurations qui modifient le fonctionnement de l'analyse, ainsi que la possibilité de l'exécuter.

AxeSelenium(OpenQA.Selenium.Remote.RemoteWebDriver, ReportConfiguration?, chaîne)

Crée un nouvel objet AxeSelenium pour une page avec une configuration spécifique.

RésultatsRapportAnalyse()

Exécuter l'analyse d'accessibilité sur la page.

Retourne : Le rapport de l’exécution d’axe-core sur la page.

var report = new AxeSelenium(driver).Analyze();

AxeSelenium Configure(Spec)

Configure axe. Réalisé via axe.configure

Retourne : Cet objet pour chaînage.

var spec = new Spec.Spec {
    Checks = new Spec.Check[] {
        new Spec.Check() {
            Id = "dylang",
            Options = (object) new string[] { "dylan" },
            Evaluate = @"function (node, options) {
              var lang = (node.getAttribute('lang') || '').trim().toLowerCase();
              var xmlLang = (node.getAttribute('xml:lang') || '').trim().toLowerCase();
              var invalid = [];
              (options || []).forEach(function(cc) {
                cc = cc.toLowerCase();
                if (lang && (lang === cc || lang.indexOf(cc.toLowerCase() + '-') === 0)) {
                  lang = null;
                }
                if (xmlLang && (xmlLang === cc || xmlLang.indexOf(cc.toLowerCase() + '-') === 0)) {
                  xmlLang = null;
                }
              });
              if (xmlLang) {
                invalid.push('xml:lang='' + xmlLang + ''');
              }
              if (lang) {
                invalid.push('lang='' + lang + ''');
              }
              if (invalid.length) {
                this.data(invalid);
                return true;
              }
              return false;
            }"
        }
    },
    Rules = new Spec.Rule[] {
        new Spec.Rule() {
            Id = "dylang",
            Selector = "html",
            Tags = new string[] { "wcag2aa" },
            All = new string[0],
            Any = new string[0],
            None = new string[] { "dylang" }
        }
    }
};
var report = new AxeSelenium(driver)
  .Configure(spec)
  .Analyze()

AxeSeleniumDésactivationRègles(string[])

Désactiver certaines règles lors de l'exécution de l'analyse.

Retourne : Cet objet pour chaînage.

var report = new AxeSelenium(driver)
  .DisablingRules("html-has-lang", "label")
  .Analyze()

AxeSeleniumExcluding(string)

Spécifiez une partie de la page à exclure de l'analyse. Pour exclure plusieurs parties non liées de la page, appelez Excluding une fois pour chacune.

Retourne : Cet objet pour chaînage.

var report = new AxeSelenium(driver)
  .Excluding(".cookie-banner")
  .Excluding(".ad-slot")
  .Analyze()

AxeSeleniumExcluding(params string[])

Spécifiez un élément à l'intérieur d'un ou plusieurs iframes imbriqués à exclure. Tous les sélecteurs sauf le dernier correspondent à un niveau d'imbrication d'iframe; le dernier correspond à l'élément à exclure à l'intérieur de l'iframe le plus interne.

Parce que le paramètre est déclaré params, Excluding(".iframe1", ".third-party-ad") et Excluding(new[] { ".iframe1", ".third-party-ad" }) sont le même appel. Dans chaque cas, les sélecteurs forment un sélecteur d'iframe unique, et non des exclusions séparées. Pour exclure plusieurs parties non liées de la page, appelez Excluding(string) une fois pour chacune.

Retourne : Cet objet pour chaînage.

// Exclude .third-party-ad inside the iframe matched by .iframe1
var report = new AxeSelenium(driver)
  .Excluding(".iframe1", ".third-party-ad")
  .Analyze()

AxeSeleniumExcluding(string[][])

Spécifiez un élément à l'intérieur d'un ou plusieurs arbres DOM shadow imbriqués à exclure. Passez un tableau interne par appel. Dans ce tableau, tous les sélecteurs sauf le dernier correspondent à un hôte shadow, et le dernier correspond à l'élément à exclure à l'intérieur de la racine shadow la plus interne.

Retourne : Cet objet pour chaînage.

// Exclude #shadow-button inside the shadow root attached to #shadow-host
var selector = new string[][] {
  new string[] { "#shadow-host", "#shadow-button" }
};
var report = new AxeSelenium(driver)
  .Excluding(selector)
  .Analyze()

AxeSelenium Excluding(FromFrames)

Spécifiez un élément à l'intérieur d'un ou plusieurs iframes imbriqués à exclure, en utilisant un sélecteur FromFrames explicite.

Retourne : Cet objet pour chaînage.

// Exclude the form inside the #payment-frame iframe
var report = new AxeSelenium(driver)
  .Excluding(new FromFrames("#payment-frame", "form"))
  .Analyze()

AxeSelenium Excluding(FromShadowDom)

Spécifiez un élément à l'intérieur d'un ou plusieurs arbres DOM shadow imbriqués à exclure, en utilisant un sélecteur FromShadowDom explicite.

Parce que axe-core correspond aux éléments par rapport à l'arbre DOM aplati, la sélection d'un nœud DOM shadow sélectionne également les descendants insérés par un élément <slot>.

Retourne : Cet objet pour chaînage.

// Exclude the #search form inside the shadow root attached to .app-header
var report = new AxeSelenium(driver)
  .Excluding(new FromShadowDom(".app-header", "form#search"))
  .Analyze()

AxeSeleniumExcluding(params object[])

Spécifiez un sélecteur qui mélange des sélecteurs CSS simples avec des objets FromFrames ou FromShadowDom, pour les cas que les autres surcharges ne peuvent pas exprimer.

Cette surcharge est sélectionnée uniquement lorsque l'appel passe plusieurs arguments, ou un seul argument qui n'est pas un des types ci-dessus. Passer un seul FromFrames ou FromShadowDom sélectionne Excluding(FromFrames) ou Excluding(FromShadowDom) à la place.

Pour atteindre un iframe qui se trouve à l'intérieur d'une racine shadow, le sélecteur FromShadowDom doit être imbriqué à l'intérieur du sélecteur FromFrames; l'inverse provoque une erreur.

Retourne : Cet objet pour chaînage.

// Exclude .target inside the shadow root attached to #host, inside the #frame iframe
var report = new AxeSelenium(driver)
  .Excluding("#frame", new FromShadowDom("#host", ".target"))
  .Analyze()

AxeSeleniumIncluding(string)

Spécifiez une partie de la page à analyser. Pour analyser plusieurs parties non liées de la page, appelez Including une fois pour chacune.

Retourne : Cet objet pour chaînage.

var report = new AxeSelenium(driver)
  .Including(".sidebar")
  .Including(".some-class")
  .Analyze()

AxeSeleniumIncluding(params string[])

Spécifiez un élément à l'intérieur d'un ou plusieurs iframes imbriqués à tester. Tous les sélecteurs sauf le dernier correspondent à un niveau d'imbrication d'iframe; le dernier correspond à l'élément à tester à l'intérieur de l'iframe le plus interne.

Parce que le paramètre est déclaré params, Including(".sidebar-frame", ".some-class") et Including(new[] { ".sidebar-frame", ".some-class" }) sont le même appel. Dans chaque cas, les sélecteurs forment un sélecteur d'iframe unique, et non des inclusions séparées. Pour tester plusieurs parties non liées de la page, appelez Including(string) une fois pour chacune.

Retourne : Cet objet pour chaînage.

// Test .some-class inside the iframe matched by .sidebar-frame
var report = new AxeSelenium(driver)
  .Including(".sidebar-frame", ".some-class")
  .Analyze()

AxeSeleniumIncluding(string[][])

Spécifiez un élément à l'intérieur d'un ou plusieurs arbres DOM shadow imbriqués à tester. Passez un tableau interne par appel. Dans ce tableau, tous les sélecteurs sauf le dernier correspondent à un hôte shadow, et le dernier correspond à l'élément à tester à l'intérieur de la racine shadow la plus interne.

Retourne : Cet objet pour chaînage.

// Test #shadow-button inside the shadow root attached to #shadow-host
var selector = new string[][] {
  new string[] { "#shadow-host", "#shadow-button" }
};
var report = new AxeSelenium(driver)
  .Including(selector)
  .Analyze()

AxeSelenium Including(FromFrames)

Spécifiez un élément à l'intérieur d'un ou plusieurs iframes imbriqués à tester, en utilisant un sélecteur FromFrames explicite.

Retourne : Cet objet pour chaînage.

// Test the form inside the #payment-frame iframe
var report = new AxeSelenium(driver)
  .Including(new FromFrames("#payment-frame", "form"))
  .Analyze()

AxeSelenium Incluant(FromShadowDom)

Spécifiez un élément à l'intérieur d'un ou plusieurs arbres DOM ombrés imbriqués pour tester, en utilisant un sélecteur FromShadowDom explicite.

Parce que axe-core compare les éléments par rapport à l'arborescence DOM aplatie, la sélection d'un nœud DOM ombré sélectionne également tous les descendants insérés à travers un élément <slot>.

Retourne : Cet objet pour chaînage.

// Test the #search form inside the shadow root attached to .app-header
var report = new AxeSelenium(driver)
  .Including(new FromShadowDom(".app-header", "form#search"))
  .Analyze()

AxeSeleniumIncluant(objet params[])

Spécifiez un sélecteur qui mélange des sélecteurs CSS simples avec des objets FromFrames ou FromShadowDom, pour des cas que les autres surcharges ne peuvent exprimer.

Cette surcharge est sélectionnée uniquement lorsque l'appel passe plus d'un argument, ou un seul argument qui n'est pas l'un des types susmentionnés. Passer un seul FromFrames ou FromShadowDom sélectionne Including(FromFrames) ou Including(FromShadowDom) à la place.

Pour atteindre une iframe qui se trouve à l'intérieur d'une racine shadow, le sélecteur FromShadowDom doit être imbriqué à l'intérieur du sélecteur FromFrames ; l'inverse provoque une erreur.

Retourne : Cet objet pour chaînage.

// Test .target inside the shadow root attached to #host, inside the #frame iframe
var report = new AxeSelenium(driver)
  .Including("#frame", new FromShadowDom("#host", ".target"))
  .Analyze()

AxeSelenium RunOptions(Options d'exécution)

Spécifiez RunOptions pour passer à travers lors de l'appel de axe.run.

Retourne : Cet objet pour chaînage.

var options = new RunOptions.RunOptions {
  IFrames = false,
  RunOnly = RunOptions.RunOnly.Tags(RunOptions.TagType.Wcag2a)
};
var report = new AxeSelenium(driver)
  .RunOptions(options)
  .Analyze()

AxeSeleniumWithConfigFile(string)

Indiquez où trouver un fichier de configuration. Le chemin par défaut est config/axe-ruleset.json ou $AXE_RULESET_PATH.

Retourne : Cet objet pour chaînage.

var report = new AxeSelenium(driver)
  .WithConfigFile("path/to/file.json")
  .Analyze();

AxeSeleniumWithRules(string[])

Spécifiez les règles (par identifiant) à utiliser lors de l'exécution de l'analyse.

Retourne : Cet objet pour chaînage.

var report = new AxeSelenium(driver)
  .WithRules("document-title", "label")
  .WithRules("html-has-lang")
  .Analyze()

AxeSeleniumWithRuleset(string, bool)

Utilisez un ensemble de règles spécifique (c.-à-d. wcag2.1, 508).

Retourne : Cet objet pour chaînage.

var report = new AxeSelenium(driver)
  .WithRuleset("508", true)
  .Analyze()

AxeSelenium AvecTags(TagType[])

Spécifiez les règles (par tag) à utiliser lors de l'exécution de l'analyse.

Retourne : Cet objet pour chaînage.

var report = new AxeSelenium(driver)
  .WithTags(RunTagType.BestPractice)
  .Analyze()

Variables d'environnement

Ces variables d'environnement vous permettent de configurer le service d'utilisation et de modifier les propriétés des événements signalés.

AxeSeleniumActiverSuivi(bool)

Choisissez d'envoyer ou non les données au service d'utilisation. L'envoi est activé par défaut.

Retourne : Cet objet pour chaînage.

AxeSeleniumDéfinirUrlSuivi(string)

Définir où les données des métriques d'utilisation sont envoyées. La valeur par défaut est https://usage.deque.com

Retourne : Cet objet pour chaînage.

AxeSeleniumDéfinirIdDistinct(string)

Définir l'identifiant distinct utilisé lors de l'envoi des métriques d'utilisation.

Retourne : Cet objet pour chaînage.

class Deque.AxeDevtools.Selenium.ReportConfiguration

Configure les informations spécifiques au rapport comme le nom de la suite de tests ou les informations de l'agent utilisateur

static ReportConfigurationGetDefault()

Obtient la configuration par défaut actuelle. Notez que la valeur par défaut peut être modifiée.

Retourne : La valeur par défaut actuelle.

static void ResetDefault()

Réinitialise le défaut à son état initial.

void SetAsDefault()

Définit cet objet comme défaut.

ReportConfiguration.GetDefault()
  .TestSuiteName("my-tests")
  .UIState("home-page")
  .SetAsDefault();

ReportConfigurationTestMachine(string)

Définit la machine sur laquelle ces tests ont été exécutés.

Retourne : Cet objet pour chaînage.

ReportConfigurationTestSuiteName(string)

Définit le nom de la suite de tests.

Retourne : Cet objet pour chaînage.

ReportConfigurationUIState(string)

Spécifie l'état de l'interface utilisateur pour cet ensemble de tests. Utilisé comme identifiant.

Retourne : Cet objet pour chaînage.

ReportConfigurationUserAgent(string)

Définit l'agent utilisateur utilisé lors des tests.

Retourne : Cet objet pour chaînage.

class Deque.AxeDevtools.Selenium.Results.Check

Le résultat de l'exécution d'une vérification.

class Deque.AxeDevtools.Selenium.Results.CheckedNode

Un nœud HTML qui a été vérifié par une règle.

class Deque.AxeDevtools.Results.FromFrames

Un sélecteur qui cible un élément à l'intérieur d'un ou plusieurs iframes imbriqués. Passez-le à Including(FromFrames) ou Excluding(FromFrames).

FromFrames(objet params[])

var report = new AxeSelenium(driver)
  .Including(new FromFrames("iframe#outer", "iframe#inner", "form"))
  .Analyze()

class Deque.AxeDevtools.Results.FromShadowDom

Un sélecteur qui cible un élément à l'intérieur d'un ou plusieurs arbres DOM ombrés imbriqués. Passez-le à Including(FromShadowDom) ou Excluding(FromShadowDom).

FromShadowDom(params string[])

var report = new AxeSelenium(driver)
  .Including(new FromShadowDom("app-root", ".header", "#search"))
  .Analyze()

class Deque.AxeDevtools.Selenium.Results.Node

Spécifie un nœud HTML spécifique.

class Deque.AxeDevtools.Selenium.Results.Platform

La plateforme sur laquelle un test a été exécuté.

class Deque.AxeDevtools.Selenium.Results.ReportResults

Résultats d'un test compatibles avec le format du rapporteur.

var axe = new AxeSelenium(driver, ReportConfiguration.GetDefault().UIState("UIState"));
var res = axe.Analyze();
File.WriteAllText(reportPath, JsonConvert.SerializeObject(res));

class Deque.AxeDevtools.Selenium.Results.Rule

Résultat pour une règle unique.

class Deque.AxeDevtools.Selenium.Results.TestEngine

Informations sur le moteur axe-core sur lequel le test a été exécuté.

class Deque.AxeDevtools.Selenium.Results.TestEnvironment

Informations sur l'environnement dans lequel le test a été effectué.

class Deque.AxeDevtools.Selenium.Results.TestResults

Résultats renvoyés après avoir exécuté l'analyse sur la page.

class Deque.AxeDevtools.Selenium.Results.TestRunner

Nom de l'exécuteur de test.

class Deque.AxeDevtools.Selenium.Results.TestSubject

Informations sur ce qui est testé.

class Deque.AxeDevtools.Selenium.RunOptions.Context

Spécifiez quel élément doit être testé et lequel ne doit pas l'être.

void Excluding(string[])

Ajoutez un ensemble de sélecteurs pour les éléments qui ne doivent pas être testés.

void Including(string[])

Ajoutez un ensemble de sélecteurs pour les éléments qui doivent être testés.

enum Deque.AxeDevtools.Selenium.RunOptions.ResultGroup

• Réussites
• Violations
• Incomplet
• Inapplicable

class Deque.AxeDevtools.Selenium.RunOptions.RuleStatus

Active ou désactive une règle.

class Deque.AxeDevtools.Selenium.RunOptions.RunOnly

Limiter les règles exécutées, basées sur les noms ou les tags.

static ExécuterSeulementRules(string[])

Construisez un limiteur pour les règles basées sur les identifiants.

Retourne : L'objet RunOnly.

statique ExécuterSeulement Tags(TagType[])

Construire un limiteur pour les règles basées sur les tags.

Retourne : L'objet RunOnly.

enum Deque.AxeDevtools.Selenium.RunOptions.RunOnlyType

• Règle
• Règles
• Tag
• Tags

class Deque.AxeDevtools.Selenium.RunOptions.RunOptions

Une configuration flexible sur la façon dont l'analyse fonctionne.

enum Deque.AxeDevtools.Selenium.RunOptions.TagType

• Wcag2a
• Wcag2aa
• Wcag2aaa
• Wcag21a
• Wcag21aa
• Wcag21aaa
• Wcag22a
• Wcag22aa
• Wcag22aaa
• Section508
• TTv5
• EN301549
• RGAAv4
• BestPractice

class Deque.AxeDevtools.Selenium.Spec.Check

Utilisé pour ajouter des vérifications à la liste des vérifications utilisées par les règles, ou pour remplacer les propriétés des vérifications existantes.

class Deque.AxeDevtools.Selenium.Spec.Rule

Utilisé pour ajouter des règles à l'ensemble existant de règles, ou pour remplacer les propriétés des règles existantes.

class Deque.AxeDevtools.Selenium.Spec.Spec

Configure le format des données de règle. Cela peut être utilisé pour ajouter de nouvelles règles, qui doivent être enregistrées avec la bibliothèque pour être exécutées.