axe-core 2.4.1 → 2.6.1

package/test/commons/dom/is-natively-focusable.js

@@ -0,0 +1,138 @@
+describe('dom.isNativelyFocusable', function () {
+	'use strict';
+
+	var fixture = document.getElementById('fixture');
+
+	afterEach(function () {
+		document.getElementById('fixture').innerHTML = '';
+	});
+
+
+	it('should return true for buttons with redundant tabindex', function () {
+		fixture.innerHTML = '<button tabindex="0" id="target"></button>';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return true for buttons with tabindex -1', function () {
+		fixture.innerHTML = '<button tabindex="-1" id="target"></button>';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return true for visible, enabled textareas', function () {
+		fixture.innerHTML = '<textarea id="target"></textarea>';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return true for visible, enabled selects', function () {
+		fixture.innerHTML = '<select id="target"></select>';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return true for visible, enabled buttons', function () {
+		fixture.innerHTML = '<button id="target"></button>';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return true for visible, enabled, non-hidden inputs', function () {
+		fixture.innerHTML = '<input type="text" id="target">';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for disabled elements', function () {
+		fixture.innerHTML = '<input type="text" id="target" disabled>';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for hidden inputs', function () {
+		fixture.innerHTML = '<input type="hidden" id="target">';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for non-visible elements', function () {
+		fixture.innerHTML = '<input type="text" id="target" style="display: none">';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return true for an anchor with an href', function () {
+		fixture.innerHTML = '<a href="something.html" id="target"></a>';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for an anchor with no href', function () {
+		fixture.innerHTML = '<a name="anchor" id="target"></a>';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for a div with a tabindex with spaces', function () {
+		fixture.innerHTML = '<div id="target" tabindex="	  0   "></div>';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for a div with a tabindex', function () {
+		fixture.innerHTML = '<div id="target" tabindex="0"></div>';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for a div with a non-numeric tabindex', function () {
+		fixture.innerHTML = '<div id="target" tabindex="x"></div>';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return true for a details element', function () {
+		fixture.innerHTML = '<details id="target"><p>Detail</p></details>';
+		var el = document.getElementById('target');
+
+		assert.isTrue(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+
+	it('should return false for a div with no tabindex', function () {
+		fixture.innerHTML = '<div id="target"></div>';
+		var el = document.getElementById('target');
+
+		assert.isFalse(axe.commons.dom.isNativelyFocusable(el));
+
+	});
+});

package/test/commons/index.html

@@ -29,6 +29,7 @@
 	<body>
 		<div id="mocha"></div>
 		<div id="fixture"></div>
+		<script src="/test/testutils.js"></script>
 		
 			<script src="aria/attributes.js"></script>
 		
@@ -66,6 +67,8 @@
 		
 			<script src="dom/is-in-text-block.js"></script>
 		
+			<script src="dom/is-natively-focusable.js"></script>
+		
 			<script src="dom/is-node.js"></script>
 		
 			<script src="dom/is-offscreen.js"></script>

package/test/core/base/audit.js

@@ -149,6 +149,54 @@ describe('Audit', function () {
 				'https://dequeuniversity.com/rules/thing/x.y/target2?application=axeAPI'
 			);
 		});
+		it('understands prerelease type version numbers', function () {
+			var tempVersion = axe.version;
+			var audit = new Audit();
+			audit.addRule({
+				id: 'target',
+				matches: 'function () {return "hello";}',
+				selector: 'bob'
+			});
+
+			axe.version = '3.2.1-alpha.0';
+			audit._constructHelpUrls();
+
+			axe.version = tempVersion;
+			assert.equal(audit.data.rules.target.helpUrl,
+				'https://dequeuniversity.com/rules/axe/3.2/target?application=axeAPI');
+		});
+		it('sets x.y as version for invalid versions', function () {
+			var tempVersion = axe.version;
+			var audit = new Audit();
+			audit.addRule({
+				id: 'target',
+				matches: 'function () {return "hello";}',
+				selector: 'bob'
+			});
+
+			axe.version = 'in-3.0-valid';
+			audit._constructHelpUrls();
+
+			axe.version = tempVersion;
+			assert.equal(audit.data.rules.target.helpUrl,
+				'https://dequeuniversity.com/rules/axe/x.y/target?application=axeAPI');
+		});
+		it('matches major release versions', function () {
+			var tempVersion = axe.version;
+			var audit = new Audit();
+			audit.addRule({
+				id: 'target',
+				matches: 'function () {return "hello";}',
+				selector: 'bob'
+			});
+
+			axe.version = '1.0.0';
+			audit._constructHelpUrls();
+
+			axe.version = tempVersion;
+			assert.equal(audit.data.rules.target.helpUrl,
+				'https://dequeuniversity.com/rules/axe/1.0/target?application=axeAPI');
+		});
 	});
 
 	describe('Audit#setBranding', function () {

package/test/core/base/check.js

@@ -193,7 +193,7 @@ describe('Check', function () {
 					}
 				}).run(fixture, {}, function (d) {
 					assert.instanceOf(d, CheckResult);
-					assert.deepEqual(d.value, data);
+					assert.deepEqual(d.result, data);
 					done();
 				});
 

package/test/core/index.html

@@ -78,9 +78,9 @@
 		
 			<script src="/tmp/core/utils/aggregateChecks.js"></script>
 		
-			<script src="/tmp/core/utils/aggregateResult.js"></script>
+			<script src="/tmp/core/utils/aggregateNodeResults.js"></script>
 		
-			<script src="/tmp/core/utils/aggregateRule.js"></script>
+			<script src="/tmp/core/utils/aggregateResult.js"></script>
 		
 			<script src="/tmp/core/utils/are-styles-set.js"></script>
 		
@@ -118,6 +118,8 @@
 		
 			<script src="/tmp/core/utils/is-hidden.js"></script>
 		
+			<script src="/tmp/core/utils/is-xhtml.js"></script>
+		
 			<script src="/tmp/core/utils/merge-results.js"></script>
 		
 			<script src="/tmp/core/utils/node-sorter.js"></script>
@@ -149,6 +151,7 @@
 	<body>
 		<div id="mocha"></div>
 		<div id="fixture"></div>
+		<script src="/test/testutils.js"></script>
 		
 			<script src="base/audit.js"></script>
 		
@@ -194,6 +197,8 @@
 		
 			<script src="reporters/helpers/incomplete-fallback-msg.js"></script>
 		
+			<script src="reporters/helpers/process-aggregate.js"></script>
+		
 			<script src="reporters/na.js"></script>
 		
 			<script src="reporters/no-passes.js"></script>
@@ -208,9 +213,9 @@
 		
 			<script src="utils/aggregateChecks.js"></script>
 		
-			<script src="utils/aggregateResult.js"></script>
+			<script src="utils/aggregateNodeResults.js"></script>
 		
-			<script src="utils/aggregateRule.js"></script>
+			<script src="utils/aggregateResult.js"></script>
 		
 			<script src="utils/are-styles-set.js"></script>
 		
@@ -248,6 +253,8 @@
 		
 			<script src="utils/is-hidden.js"></script>
 		
+			<script src="utils/is-xhtml.js"></script>
+		
 			<script src="utils/merge-results.js"></script>
 		
 			<script src="utils/node-sorter.js"></script>

package/test/core/public/run-rules.js

@@ -67,7 +67,6 @@ describe('runRules', function () {
 			}
 		}], messages: {}});
 
-
 		var frame = document.createElement('iframe');
 		frame.src = '../mock/frames/frame-frame.html';
 
@@ -621,4 +620,31 @@ describe('runRules', function () {
 		});
 		fixture.appendChild(frame);
 	});
+
+	it('should not fail if `include` / `exclude` is overwritten', function (done) {
+		function invalid () {
+			throw new Error('nope!');
+		}
+		Array.prototype.include = invalid;
+		Array.prototype.exclude = invalid;
+
+		axe._load({ rules: [{
+			id: 'html',
+			selector: 'html',
+			any: ['html']
+		}], checks: [{
+			id: 'html',
+			evaluate: function () {
+				return true;
+			}
+		}], messages: {}});
+
+		runRules([document], {}, function (r) {
+			assert.lengthOf(r[0].passes, 1);
+
+			delete Array.prototype.include;
+			delete Array.prototype.exclude;
+			done();
+		}, isNotCalled);
+	});
 });

package/test/core/reporters/helpers/process-aggregate.js

@@ -0,0 +1,290 @@
+
+describe('helpers.processAggregate', function () {
+  'use strict';
+  var results, options;
+
+  beforeEach(function () {
+    results = [{
+      id: 'passed-rule',
+      passes: [{
+        result: 'passed',
+        node: {
+          element: document.createElement('div'),
+          selector: 'header > .thing',
+          source: '<div class=\"thing\">Thing</div>',
+          xpath: '/header/div[@class="thing"]'
+        },
+        any: [{
+          id: 'passed-rule',
+          relatedNodes: [{
+            element: document.createElement('div'),
+            selector: 'footer > .thing',
+            source: '<div class=\"thing\">Thing</div>',
+            xpath: '/footer/div[@class="thing"]',
+          }]
+        }],
+        all: [],
+        none: []
+      }, {
+        result: 'passed',
+        node: {
+          element: document.createElement('div'),
+          selector: 'main > .thing',
+          source: '<div class=\"thing\">Thing</div>',
+          xpath: '/main/div[@class="thing"]'
+        },
+        any: [{
+          id: 'passed-rule',
+          relatedNodes: [{
+            element: document.createElement('div'),
+            selector: 'footer > .thing',
+            source: '<div class=\"thing\">Thing</div>',
+            xpath: '/footer/div[@class="thing"]',
+          }]
+        }],
+        all: [],
+        none: []
+      }],
+      inapplicable: [],
+      incomplete: [],
+      violations: []
+    }, {
+      id: 'failed-rule',
+        violations: [{
+        result: 'failed',
+        node: {
+          selector: '#dopel',
+          source: '<input id=\"dopel\"/>',
+          xpath: '/main/input[@id="dopel"]',
+          fromFrame: true
+        },
+        any: [{
+          id: 'failed-rule',
+          relatedNodes: [{
+            element: document.createElement('input'),
+            selector: '#dopel',
+            source: '<input id=\"dopel\"/>',
+            xpath: '/main/input[@id="dopel"]',
+            fromFrame: true
+          }]
+        }],
+        all: [],
+        none: []
+      }, {
+        result: 'failed',
+        node: {
+          selector: '#dopell',
+          source: '<input id=\"dopell\"/>',
+          xpath: '/header/input[@id="dopell"]',
+          fromFrame: true
+        },
+        any: [{
+          id: 'failed-rule',
+          relatedNodes: [{
+            element: document.createElement('input'),
+            selector: '#dopell',
+            source: '<input id=\"dopell\"/>',
+            xpath: '/header/input[@id="dopell"]',
+            fromFrame: true
+          }]
+        }],
+        all: [],
+        none: []
+      }],
+      inapplicable: [],
+      passes: [],
+      incomplete: []
+    }];
+  });
+
+  it('should add a `timestamp` property to the `resultObject`', function () {
+    var resultObject = helpers.processAggregate(results, {});
+    assert.isDefined(resultObject.timestamp);
+  });
+
+  it('should add a `url` property to the `resultObject`', function () {
+    var resultObject = helpers.processAggregate(results, {});
+    assert.isDefined(resultObject.url);
+  });
+
+  it('should remove the `result` property from each node in each ruleResult', function () {
+    assert.isDefined(results.find(function (r) {
+      return r.id === 'passed-rule';
+    }).passes[0].result);
+
+    var resultObject = helpers.processAggregate(results, {});
+    var ruleResult = resultObject.passes.find(function (r) {
+      return r.id === 'passed-rule';
+    });
+    assert.isUndefined(ruleResult.nodes[0].result);
+  });
+
+  it('should remove the `node` property from each node in each ruleResult', function () {
+    assert.isDefined(results.find(function (r) {
+      return r.id === 'passed-rule';
+    }).passes[0].node);
+
+    var resultObject = helpers.processAggregate(results, {});
+    var ruleResult = resultObject.passes.find(function (r) {
+      return r.id === 'passed-rule';
+    });
+    assert.isUndefined(ruleResult.nodes[0].node);
+  });
+
+  describe('`options` argument', function () {
+
+    describe('`resultTypes` option', function () {
+
+      it('should reduce the unwanted result types to 1 in the `resultObject`', function () {
+        var resultObject = helpers.processAggregate(results, { resultTypes: ['violations'] });
+        assert.isDefined(resultObject.passes);
+        assert.equal(resultObject.passes[0].nodes.length, 1);
+        assert.isDefined(resultObject.violations);
+        assert.equal(resultObject.violations[0].nodes.length, 2);
+        resultObject = helpers.processAggregate(results, { resultTypes: ['passes'] });
+        assert.equal(resultObject.passes[0].nodes.length, 2);
+        assert.equal(resultObject.violations[0].nodes.length, 1);
+        assert.isDefined(resultObject.incomplete);
+        assert.isDefined(resultObject.inapplicable);
+      });
+    });
+
+    describe('`elementRef` option', function () {
+
+      describe('when set to true', function () {
+
+        before(function () {
+          options = { elementRef: true };
+        });
+
+        describe('when node\'s, or relatedNode\'s, `fromFrame` equals false', function () {
+          it('should add an `element` property to the subResult nodes or relatedNodes', function () {
+            var resultObject = helpers.processAggregate(results, options);
+            assert.isDefined(resultObject.passes[0].nodes[0].element);
+            assert.isDefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].element);
+          });
+        });
+
+        describe('when node\'s, or relatedNode\'s, `fromFrame` equals true', function () {
+          it('should NOT add an `element` property to the subResult nodes or relatedNodes', function () {
+            var resultObject = helpers.processAggregate(results, options);
+            assert.isUndefined(resultObject.violations[0].nodes[0].element);
+            assert.isUndefined(resultObject.violations[0].nodes[0].any[0].relatedNodes[0].element);
+          });
+        });
+      });
+
+      describe('when set to false', function () {
+
+        before(function () {
+          options = { elementRef: false };
+        });
+
+        it('should NOT add an `element` property to the subResult nodes or relatedNodes', function () {
+          var resultObject = helpers.processAggregate(results, options);
+          assert.isUndefined(resultObject.passes[0].nodes[0].element);
+          assert.isUndefined(resultObject.violations[0].nodes[0].element);
+          assert.isUndefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].element);
+          assert.isUndefined(resultObject.violations[0].nodes[0].any[0].relatedNodes[0].element);
+        });
+      });
+
+      describe('when not set at all', function () {
+
+        it('should NOT add an `element` property to the subResult nodes or relatedNodes', function () {
+          var resultObject = helpers.processAggregate(results, {});
+          assert.isUndefined(resultObject.passes[0].nodes[0].element);
+          assert.isUndefined(resultObject.violations[0].nodes[0].element);
+          assert.isUndefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].element);
+          assert.isUndefined(resultObject.violations[0].nodes[0].any[0].relatedNodes[0].element);
+        });
+      });
+    });
+
+    describe('`selectors` option', function () {
+
+      describe('when set to false', function () {
+
+        before(function () {
+          options = { selectors: false };
+        });
+
+        describe('when node\'s, or relatedNode\'s, `fromFrame` equals true', function () {
+          it('should add a `target` property to the subResult nodes or relatedNodes', function () {
+            var resultObject = helpers.processAggregate(results, options);
+            assert.isDefined(resultObject.violations[0].nodes[0].target);
+            assert.isDefined(resultObject.violations[0].nodes[0].any[0].relatedNodes[0].target);
+          });
+        });
+
+        describe('when node\'s, or relatedNode\'s, `fromFrame` equals false', function () {
+          it('should NOT add a `target` property to the subResult nodes or relatedNodes', function () {
+            var resultObject = helpers.processAggregate(results, options);
+            assert.isUndefined(resultObject.passes[0].nodes[0].target);
+            assert.isUndefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].target);
+          });
+        });
+      });
+
+      describe('when set to true', function () {
+
+        before(function () {
+          options = { selectors: true };
+        });
+
+        it('should add a `target` property to the subResult nodes or relatedNodes', function () {
+          var resultObject = helpers.processAggregate(results, options);
+          assert.isDefined(resultObject.passes[0].nodes[0].target);
+          assert.isDefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].target);
+        });
+      });
+
+      describe('when not set at all', function () {
+
+        it('should add a `target` property to the subResult nodes or relatedNodes', function () {
+          var resultObject = helpers.processAggregate(results, {});
+          assert.isDefined(resultObject.passes[0].nodes[0].target);
+          assert.isDefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].target);
+        });
+      });
+    });
+
+    describe('`xpath` option', function () {
+
+      describe('when set to true', function () {
+
+        before(function () {
+          options = { xpath: true };
+        });
+
+        it('should add an `xpath` property to the subResult nodes or relatedNodes', function () {
+          var resultObject = helpers.processAggregate(results, options);
+          assert.isDefined(resultObject.passes[0].nodes[0].xpath);
+          assert.isDefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].xpath);
+        });
+      });
+
+      describe('when set to false', function () {
+
+        before(function () {
+          options = { xpath: false };
+        });
+
+        it('should NOT add an `xpath` property to the subResult nodes or relatedNodes', function () {
+          var resultObject = helpers.processAggregate(results, options);
+          assert.isUndefined(resultObject.passes[0].nodes[0].xpath);
+          assert.isUndefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].xpath);
+        });
+      });
+
+      describe('when not set at all', function () {
+
+        it('should NOT add an `xpath` property to the subResult nodes or relatedNodes', function () {
+          var resultObject = helpers.processAggregate(results, {});
+          assert.isUndefined(resultObject.passes[0].nodes[0].xpath);
+          assert.isUndefined(resultObject.passes[0].nodes[0].any[0].relatedNodes[0].xpath);
+        });
+      });
+    });
+  });
+});

package/test/core/utils/{aggregateRule.js → aggregateNodeResults.js}

@@ -1,4 +1,4 @@
-describe('axe.utils.aggregateRule', function() {
+describe('axe.utils.aggregateNodeResults', function() {
 	'use strict';
 	var FAIL = 'failed';
 	var PASS = 'passed';
@@ -38,20 +38,16 @@ describe('axe.utils.aggregateRule', function() {
 	});
 
 	it('should be a function', function() {
-		assert.isFunction(axe.utils.aggregateRule);
+		assert.isFunction(axe.utils.aggregateNodeResults);
 	});
 
 	it('Should be `inapplicable` when no results are given', function () {
-		var ruleResult = axe.utils.aggregateRule( createTestResults(
-			{}, {}
-		));
-
+		var ruleResult = axe.utils.aggregateNodeResults([]);
 		assert.equal(ruleResult.result, INAPPLICABLE);
-		assert.lengthOf(ruleResult.inapplicable, 2);
 	});
 
 	it('should assign FAIL to ruleResult over PASS', function() {
-		var ruleResult = axe.utils.aggregateRule( createTestResults(
+		var ruleResult = axe.utils.aggregateNodeResults( createTestResults(
 			{ all: false },
 			{ all: true },
 			{ all: true }
@@ -62,7 +58,7 @@ describe('axe.utils.aggregateRule', function() {
 	});
 
 	it('should assign FAIL to ruleResult over CANTTELL', function() {
-		var ruleResult = axe.utils.aggregateRule( createTestResults(
+		var ruleResult = axe.utils.aggregateNodeResults( createTestResults(
 			{ all: false },
 			{ all: 0 },
 			{ all: true }
@@ -74,7 +70,7 @@ describe('axe.utils.aggregateRule', function() {
 	});
 
 	it('should assign PASS to ruleResult if there are only passing checks', function() {
-		var ruleResult = axe.utils.aggregateRule( createTestResults(
+		var ruleResult = axe.utils.aggregateNodeResults( createTestResults(
 			{ all: true },
 			{ all: true },
 			{ all: true }
@@ -86,7 +82,7 @@ describe('axe.utils.aggregateRule', function() {
 	});
 
 	it('should assign FAIL if there are no passing anys checks', function() {
-		var ruleResult = axe.utils.aggregateRule( createTestResults(
+		var ruleResult = axe.utils.aggregateNodeResults( createTestResults(
 			{ any: false },
 			{ any: false },
 			{ any: false }
@@ -97,7 +93,7 @@ describe('axe.utils.aggregateRule', function() {
 	});
 
 	it('should assign CANTTELL over PASS', function() {
-		var ruleResult = axe.utils.aggregateRule( createTestResults(
+		var ruleResult = axe.utils.aggregateNodeResults( createTestResults(
 			{ all: true },
 			{ all: 0 },
 			{ all: 0 }
@@ -108,14 +104,14 @@ describe('axe.utils.aggregateRule', function() {
 	});
 
 	it('should provide impact on incomplete', function () {
-		var ruleResult = axe.utils.aggregateRule( createTestResults({
+		var ruleResult = axe.utils.aggregateNodeResults( createTestResults({
 			none: { result: undefined, impact: 'serious' }
 		}));
 		assert.equal(ruleResult.impact, 'serious');
 	});
 
 	it('should raise the highest "raisedMetadata" on failing checks', function() {
-		var ruleResult = axe.utils.aggregateRule( createTestResults({
+		var ruleResult = axe.utils.aggregateNodeResults( createTestResults({
 				none: { result: true, impact: 'moderate' },
 				any: { result: true, impact: 'minor' },
 				all: [