Add a mechanism to ignore certain elements for accessibility audit on a per-test basis.

chrome/test/data/webui/accessibility_audit_browsertest.js

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview Tests to ensure that the accessibility audit and mechanisms
  * to enable/disable it work as expected.
  * @author aboxhall@google.com (Alice Boxhall)
  * @see test_api.js
  */
@@ skipping 20 matching lines @@
    */
   expectedWarnings: null,
 
   /**
    * Number of expected accessibility warnings, if it should be checked,
    * otherwise null.
    * @type {?number}
    */
   expectedErrors: null,
 
+  isAsync: false,
+  accessibilityAuditConfig: new axs.AuditConfiguration(),
+
   tearDown: function() {
     if (this.expectedErrors != null)
       expectEquals(this.expectedErrors, this.getAccessibilityErrors().length);
     if (this.expectedWarnings != null)
       expectEquals(this.expectedWarnings,
                    this.getAccessibilityWarnings().length);
     testing.Test.prototype.tearDown.call(this);
   }
 };
 
@@ skipping 61 matching lines @@
 /**
  * Creates an expectation that the global axs.Audit object will have its run()
  * method called |times| times.
  * This creates an interstitial mock axs.Audit object with the expectation, and
  * delegates to the real axs.Audit object to run the actual audit.
  * @param {number} times The number of times the audit is expected to run.
  */
 function expectAuditWillRun(times) {
   var audit = createMockAudit();
   var realAudit = axs.Audit;
-  var expectedInvocation = audit.expects(exactly(times)).run();
+  var expectedInvocation = audit.expects(exactly(times)).run(ANYTHING);
   var willArgs = [];
   for (var i = 0; i < times; i++)
     willArgs.push(callFunction(realAudit.run));
   expectedInvocation.will.apply(expectedInvocation, willArgs);
   axs.Audit = audit.proxy();
 }
 
 // Test that an audit failure causes a test failure, if both
 // |runAccessibilityChecks| and |accessibilityIssuesAreErrors| are true.
 TEST_F('WebUIAccessibilityAuditBrowserTest', 'testWithAuditFailures_shouldFail',
@@ skipping 48 matching lines @@
        function() {
   expectAuditWillNotRun();
   addAuditFailures();
 });
 
 // Test that the accessibility audit does run if the enableAccessibilityChecks()
 // method is called in the test function.
 TEST_F('WebUIAccessibilityAuditBrowserTest_TestsDisabledInFixture',
        'testWithAuditFailures_shouldFail',
        function() {
-         console.log(axs.Audit);
   expectAuditWillRun(1);
   this.enableAccessibilityChecks();
   addAuditFailures();
 });
 
 // Test that the accessibility audit runs when the expectAccessibilityOk()
 // method is called.
 TEST_F('WebUIAccessibilityAuditBrowserTest_TestsDisabledInFixture',
        'testRunningAuditManually_noErrors',
        function() {
@@ skipping 73 matching lines @@
   expectAccessibilityOk();
 
   this.expectedWarnings = 1;
   this.expectedErrors = 2;
   expectReportConsoleWarning();
 
   this.enableAccessibilityChecks();
 
   addAuditFailures();
 });
+
+// Tests that parts of the page can be ignored on a per-audit rule basis.
+TEST_F('WebUIAccessibilityAuditBrowserTest_IssuesAreWarnings',
+       'testCanIgnoreSelectors',
+        function() {
+  this.disableAccessibilityChecks();
+  expectAuditWillRun(2);
+
+  addAuditFailures();
+  var accessibilityErrors = [];
+  var accessibilityWarnings = [];
+  try {
+    assertAccessibilityOk(accessibilityErrors, accessibilityWarnings);
+  } catch (e) {
+  }
+  expectEquals(2, accessibilityErrors.length);
+  expectEquals(1, accessibilityWarnings.length);
+
+  accessibilityErrors.splice(0, accessibilityErrors.length);

[dmazzoni, 2012/12/21 23:21:03]

I saw this pattern before - any reason not to just do this?

accessibilityErrors.length = 0;

[aboxhall, 2013/01/16 00:01:42]

Not at all. Changed.

+  accessibilityWarnings.splice(0, accessibilityWarnings.length);
+  assertEquals(0, accessibilityErrors.length);
+  assertEquals(0, accessibilityWarnings.length);
+
+  this.accessibilityAuditConfig.ignoreSelectors('lowContrastElements', 'P');
+
+  try {
+    assertAccessibilityOk(accessibilityErrors, accessibilityWarnings);
+  } catch (e) {
+  }
+  expectEquals(2, accessibilityErrors.length);
+  // lowContrastElements should pass as the failing element is ignored.
+  expectEquals(0, accessibilityWarnings.length);
+});