From 364eb72bb8f20b0ffc31be24cc96cbd349c301cb Mon Sep 17 00:00:00 2001
From: Steven Lambert <2433219+straker@users.noreply.github.com>
Date: Tue, 15 Oct 2024 09:10:56 -0600
Subject: [PATCH] fix(button-name,input-button-name,input-img-alt): allow label
 to give accessible name (#4607)

I'm not sure if this should close #4472 as that also deals with buttons
with a different role running `button-name`. For sure this closes #3696

Closes: #3696

---------

Co-authored-by: Wilco Fiers <WilcoFiers@users.noreply.github.com>
---
 lib/checks/label/explicit.json                |   4 +-
 lib/checks/label/implicit.json                |   4 +-
 lib/commons/text/native-text-methods.js       |   5 +-
 lib/rules/button-name.json                    |   2 +
 lib/rules/input-button-name.json              |   2 +
 lib/rules/input-image-alt.json                |   9 +-
 locales/_template.json                        |   8 +-
 test/commons/text/native-text-methods.js      |  14 ++
 .../rules/button-name/button-name.html        |   4 +
 .../rules/button-name/button-name.json        |   4 +-
 .../input-button-name/input-button-name.html  |   4 +
 .../input-button-name/input-button-name.json  |   4 +-
 .../input-image-alt/input-image-alt.html      |   4 +
 .../input-image-alt/input-image-alt.json      |   9 +-
 test/integration/virtual-rules/button-name.js | 132 ++++++++++++------
 .../virtual-rules/input-button-name.js        | 123 ++++++++++++----
 .../virtual-rules/input-image-alt.js          |  90 +++++++++---
 17 files changed, 321 insertions(+), 101 deletions(-)

diff --git a/lib/checks/label/explicit.json b/lib/checks/label/explicit.json
index ab765720f8..0d4c4b0997 100644
--- a/lib/checks/label/explicit.json
+++ b/lib/checks/label/explicit.json
@@ -4,8 +4,8 @@
   "metadata": {
     "impact": "critical",
     "messages": {
-      "pass": "Form element has an explicit <label>",
-      "fail": "Form element does not have an explicit <label>",
+      "pass": "Element has an explicit <label>",
+      "fail": "Element does not have an explicit <label>",
       "incomplete": "Unable to determine if form element has an explicit <label>"
     }
   }
diff --git a/lib/checks/label/implicit.json b/lib/checks/label/implicit.json
index b51684dd67..eaa1a2da6e 100644
--- a/lib/checks/label/implicit.json
+++ b/lib/checks/label/implicit.json
@@ -4,8 +4,8 @@
   "metadata": {
     "impact": "critical",
     "messages": {
-      "pass": "Form element has an implicit (wrapped) <label>",
-      "fail": "Form element does not have an implicit (wrapped) <label>",
+      "pass": "Element has an implicit (wrapped) <label>",
+      "fail": "Element does not have an implicit (wrapped) <label>",
       "incomplete": "Unable to determine if form element has an implicit (wrapped) <label>"
     }
   }
diff --git a/lib/commons/text/native-text-methods.js b/lib/commons/text/native-text-methods.js
index 8be86e87bf..ec5022556c 100644
--- a/lib/commons/text/native-text-methods.js
+++ b/lib/commons/text/native-text-methods.js
@@ -16,15 +16,14 @@ const nativeTextMethods = {
    * @param {VirtualNode} element
    * @return {String} value text
    */
-  valueText: ({ actualNode }) => actualNode.value || '',
+  valueText: vNode => vNode.props.value || '',
 
   /**
    * Return default value of a button
    * @param {VirtualNode} element
    * @return {String} default button text
    */
-  buttonDefaultText: ({ actualNode }) =>
-    defaultButtonValues[actualNode.type] || '',
+  buttonDefaultText: vNode => defaultButtonValues[vNode.props.type] || '',
 
   /**
    * Return caption text of an HTML table element
diff --git a/lib/rules/button-name.json b/lib/rules/button-name.json
index 40de860a21..06b44c0e9e 100644
--- a/lib/rules/button-name.json
+++ b/lib/rules/button-name.json
@@ -26,6 +26,8 @@
     "aria-label",
     "aria-labelledby",
     "non-empty-title",
+    "implicit-label",
+    "explicit-label",
     "presentational-role"
   ],
   "none": []
diff --git a/lib/rules/input-button-name.json b/lib/rules/input-button-name.json
index 452fd509d5..a636c06510 100644
--- a/lib/rules/input-button-name.json
+++ b/lib/rules/input-button-name.json
@@ -27,6 +27,8 @@
     "aria-label",
     "aria-labelledby",
     "non-empty-title",
+    "implicit-label",
+    "explicit-label",
     "presentational-role"
   ],
   "none": []
diff --git a/lib/rules/input-image-alt.json b/lib/rules/input-image-alt.json
index e3c40ac80a..416be1c5dd 100644
--- a/lib/rules/input-image-alt.json
+++ b/lib/rules/input-image-alt.json
@@ -23,6 +23,13 @@
     "help": "Image buttons must have alternative text"
   },
   "all": [],
-  "any": ["non-empty-alt", "aria-label", "aria-labelledby", "non-empty-title"],
+  "any": [
+    "non-empty-alt",
+    "aria-label",
+    "aria-labelledby",
+    "non-empty-title",
+    "implicit-label",
+    "explicit-label"
+  ],
   "none": []
 }
diff --git a/locales/_template.json b/locales/_template.json
index 06a5013af1..b250b8cdaf 100644
--- a/locales/_template.json
+++ b/locales/_template.json
@@ -771,8 +771,8 @@
       "fail": "Element contains <img> element with alt text that duplicates existing text"
     },
     "explicit-label": {
-      "pass": "Form element has an explicit <label>",
-      "fail": "Form element does not have an explicit <label>",
+      "pass": "Element has an explicit <label>",
+      "fail": "Element does not have an explicit <label>",
       "incomplete": "Unable to determine if form element has an explicit <label>"
     },
     "help-same-as-label": {
@@ -785,8 +785,8 @@
       "incomplete": "Unable to determine if form element has explicit <label> that is hidden"
     },
     "implicit-label": {
-      "pass": "Form element has an implicit (wrapped) <label>",
-      "fail": "Form element does not have an implicit (wrapped) <label>",
+      "pass": "Element has an implicit (wrapped) <label>",
+      "fail": "Element does not have an implicit (wrapped) <label>",
       "incomplete": "Unable to determine if form element has an implicit (wrapped) <label>"
     },
     "label-content-name-mismatch": {
diff --git a/test/commons/text/native-text-methods.js b/test/commons/text/native-text-methods.js
index 7cc6efc32d..c1700ab201 100644
--- a/test/commons/text/native-text-methods.js
+++ b/test/commons/text/native-text-methods.js
@@ -39,6 +39,20 @@ describe('text.nativeTextMethods', () => {
       const input = axe.utils.querySelectorAll(axe._tree[0], 'input')[0];
       assert.equal(buttonDefaultText(input), '');
     });
+
+    it('returns the default button text with mixed-case types', () => {
+      fixtureSetup(
+        '<input type="SUBMIT" />' +
+          '<input type="ImAGE" />' +
+          '<input type="ResET" />' +
+          '<input type="buTTON" />'
+      );
+      const inputs = axe.utils.querySelectorAll(axe._tree[0], 'input');
+      assert.equal(buttonDefaultText(inputs[0]), 'Submit');
+      assert.equal(buttonDefaultText(inputs[1]), 'Submit');
+      assert.equal(buttonDefaultText(inputs[2]), 'Reset');
+      assert.equal(buttonDefaultText(inputs[3]), '');
+    });
   });
 
   describe('altText', () => {
diff --git a/test/integration/rules/button-name/button-name.html b/test/integration/rules/button-name/button-name.html
index b3bef1c537..129304e173 100644
--- a/test/integration/rules/button-name/button-name.html
+++ b/test/integration/rules/button-name/button-name.html
@@ -20,6 +20,10 @@
 <button id="pass1" role="presentation" disabled></button>
 <button id="pass2" role="none" disabled></button>
 
+<label>Name<button id="pass3"></button></label>
+<label for="pass4">Name</label>
+<button id="pass4"></button>
+
 <span id="inapplicable1" role="button">Does not apply</span>
 <input type="submit" value="submit" role="button" id="inapplicable2" />
 <button id="inapplicable2" role="gridcell" disabled></button>
diff --git a/test/integration/rules/button-name/button-name.json b/test/integration/rules/button-name/button-name.json
index 2ae4a86502..432daca115 100644
--- a/test/integration/rules/button-name/button-name.json
+++ b/test/integration/rules/button-name/button-name.json
@@ -20,6 +20,8 @@
     ["#combo"],
     ["#buttonTitle"],
     ["#pass1"],
-    ["#pass2"]
+    ["#pass2"],
+    ["#pass3"],
+    ["#pass4"]
   ]
 }
diff --git a/test/integration/rules/input-button-name/input-button-name.html b/test/integration/rules/input-button-name/input-button-name.html
index 0019d982e6..a1f483e3ac 100644
--- a/test/integration/rules/input-button-name/input-button-name.html
+++ b/test/integration/rules/input-button-name/input-button-name.html
@@ -24,6 +24,10 @@
   <input type="button" role="none" id="pass12" disabled />
   <input type="button" role="presentation" id="pass13" disabled />
 
+  <label>Name<input type="button" id="pass14" /></label>
+  <label for="pass15">Name</label>
+  <input type="button" id="pass15" />
+
   <input type="button" id="fail9" role="img" disabled />
   <input type="button" id="fail10" role="gridcell" />
   <input type="button" id="inapplicable1" role="gridcell" disabled />
diff --git a/test/integration/rules/input-button-name/input-button-name.json b/test/integration/rules/input-button-name/input-button-name.json
index 6a92578341..7521299031 100644
--- a/test/integration/rules/input-button-name/input-button-name.json
+++ b/test/integration/rules/input-button-name/input-button-name.json
@@ -26,6 +26,8 @@
     ["#pass10"],
     ["#pass11"],
     ["#pass12"],
-    ["#pass13"]
+    ["#pass13"],
+    ["#pass14"],
+    ["#pass15"]
   ]
 }
diff --git a/test/integration/rules/input-image-alt/input-image-alt.html b/test/integration/rules/input-image-alt/input-image-alt.html
index 8823830a52..de92c53ca9 100644
--- a/test/integration/rules/input-image-alt/input-image-alt.html
+++ b/test/integration/rules/input-image-alt/input-image-alt.html
@@ -15,6 +15,10 @@
   <input type="image" src="img.jpg" id="pass4" title="monkeys" />
   <input type="image" src="img.jpg" id="violation5" alt="" />
 
+  <label>Name<input type="image" src="img.jpg" id="pass5" /></label>
+  <label for="pass6">Name</label>
+  <input type="image" src="img.jpg" id="pass6" />
+
   <input type="image" src="img.jpg" id="violation6" role="img" disabled />
   <input type="image" src="img.jpg" id="violation7" role="gridcell" />
   <input
diff --git a/test/integration/rules/input-image-alt/input-image-alt.json b/test/integration/rules/input-image-alt/input-image-alt.json
index d17004deae..03a9286655 100644
--- a/test/integration/rules/input-image-alt/input-image-alt.json
+++ b/test/integration/rules/input-image-alt/input-image-alt.json
@@ -10,5 +10,12 @@
     ["#violation6"],
     ["#violation7"]
   ],
-  "passes": [["#pass1"], ["#pass2"], ["#pass3"], ["#pass4"]]
+  "passes": [
+    ["#pass1"],
+    ["#pass2"],
+    ["#pass3"],
+    ["#pass4"],
+    ["#pass5"],
+    ["#pass6"]
+  ]
 }
diff --git a/test/integration/virtual-rules/button-name.js b/test/integration/virtual-rules/button-name.js
index 74e2782332..d54ef0f62d 100644
--- a/test/integration/virtual-rules/button-name.js
+++ b/test/integration/virtual-rules/button-name.js
@@ -1,6 +1,6 @@
-describe('button-name virtual-rule', function () {
-  it('should pass for aria-label', function () {
-    var results = axe.runVirtualRule('button-name', {
+describe('button-name virtual-rule', () => {
+  it('should pass for aria-label', () => {
+    const results = axe.runVirtualRule('button-name', {
       nodeName: 'button',
       attributes: {
         'aria-label': 'foobar'
@@ -12,21 +12,24 @@ describe('button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should incomplete for aria-labelledby', function () {
-    var results = axe.runVirtualRule('button-name', {
+  it('should incomplete for aria-labelledby', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button',
       attributes: {
         'aria-labelledby': 'foobar'
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 0);
     assert.lengthOf(results.incomplete, 1);
   });
 
-  it('should pass for title', function () {
-    var results = axe.runVirtualRule('button-name', {
+  it('should pass for title', () => {
+    const results = axe.runVirtualRule('button-name', {
       nodeName: 'button',
       attributes: {
         title: 'foobar'
@@ -38,8 +41,8 @@ describe('button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for role=presentation when disabled', function () {
-    var results = axe.runVirtualRule('button-name', {
+  it('should pass for role=presentation when disabled', () => {
+    const results = axe.runVirtualRule('button-name', {
       nodeName: 'button',
       attributes: {
         role: 'presentation',
@@ -52,8 +55,8 @@ describe('button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for role=none when disabled', function () {
-    var results = axe.runVirtualRule('button-name', {
+  it('should pass for role=none when disabled', () => {
+    const results = axe.runVirtualRule('button-name', {
       nodeName: 'button',
       attributes: {
         role: 'none',
@@ -66,30 +69,30 @@ describe('button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for visible text content', function () {
-    var node = new axe.SerialVirtualNode({
+  it('should pass for visible text content', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button'
     });
-    var child = new axe.SerialVirtualNode({
+    const child = new axe.SerialVirtualNode({
       nodeName: '#text',
       nodeType: 3,
       nodeValue: 'foobar'
     });
     node.children = [child];
 
-    var results = axe.runVirtualRule('button-name', node);
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 1);
     assert.lengthOf(results.violations, 0);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail for hidden text', function () {
-    var button = new axe.SerialVirtualNode({
+  it('should fail for hidden text', () => {
+    const button = new axe.SerialVirtualNode({
       nodeName: 'button'
     });
 
-    var span = new axe.SerialVirtualNode({
+    const span = new axe.SerialVirtualNode({
       nodeName: 'span',
       attributes: {
         'aria-hidden': true
@@ -98,119 +101,168 @@ describe('button-name virtual-rule', function () {
     span.parent = button;
     button.children = [span];
 
-    var text = new axe.SerialVirtualNode({
+    const text = new axe.SerialVirtualNode({
       nodeName: '#text',
       nodeType: 3,
       nodeValue: 'foobar'
     });
     text.parent = span;
     span.children = [text];
+    button.parent = null;
 
-    var results = axe.runVirtualRule('button-name', button);
+    const results = axe.runVirtualRule('button-name', button);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should incomplete when alt and children are missing', function () {
-    var results = axe.runVirtualRule('button-name', {
+  it('should incomplete when alt and children are missing', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button',
       attributes: {}
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 0);
     assert.lengthOf(results.incomplete, 1);
   });
 
-  it('should fail children contain no visible text', function () {
-    var node = new axe.SerialVirtualNode({
+  it('should fail children contain no visible text', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button'
     });
     node.children = [];
+    node.parent = null;
 
-    var results = axe.runVirtualRule('button-name', node);
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when alt contains only whitespace', function () {
-    var node = new axe.SerialVirtualNode({
+  it('should fail when alt contains only whitespace', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button',
       attributes: {
         alt: ' \t   \n   '
       }
     });
     node.children = [];
+    node.parent = null;
 
-    var results = axe.runVirtualRule('button-name', node);
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when aria-label is empty', function () {
-    var node = new axe.SerialVirtualNode({
+  it('should fail when aria-label is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button',
       attributes: {
         alt: ''
       }
     });
     node.children = [];
+    node.parent = null;
 
-    var results = axe.runVirtualRule('button-name', node);
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when title is empty', function () {
-    var node = new axe.SerialVirtualNode({
+  it('should fail when title is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button',
       attributes: {
         title: ''
       }
     });
     node.children = [];
+    node.parent = null;
 
-    var results = axe.runVirtualRule('button-name', node);
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail for role=presentation', function () {
-    var node = new axe.SerialVirtualNode({
+  it('should pass for implicit label', function () {
+    const node = new axe.SerialVirtualNode({
+      nodeName: 'button'
+    });
+    const parent = new axe.SerialVirtualNode({
+      nodeName: 'label'
+    });
+    const child = new axe.SerialVirtualNode({
+      nodeName: '#text',
+      nodeType: 3,
+      nodeValue: 'foobar'
+    });
+    node.parent = parent;
+    node.children = [];
+    parent.children = [child, node];
+
+    const results = axe.runVirtualRule('button-name', node);
+
+    assert.lengthOf(results.passes, 1);
+    assert.lengthOf(results.violations, 0);
+    assert.lengthOf(results.incomplete, 0);
+  });
+
+  it('should incomplete for explicit label', function () {
+    const node = new axe.SerialVirtualNode({
+      nodeName: 'button',
+      attributes: {
+        id: 'foobar'
+      }
+    });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('button-name', node);
+
+    assert.lengthOf(results.passes, 0);
+    assert.lengthOf(results.violations, 0);
+    assert.lengthOf(results.incomplete, 1);
+  });
+
+  it('should fail for role=presentation', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button',
       attributes: {
         role: 'presentation'
       }
     });
     node.children = [];
+    node.parent = null;
 
-    var results = axe.runVirtualRule('button-name', node);
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail for role=none', function () {
-    var node = new axe.SerialVirtualNode({
+  it('should fail for role=none', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'button',
       attributes: {
         role: 'none'
       }
     });
     node.children = [];
+    node.parent = null;
 
-    var results = axe.runVirtualRule('button-name', node);
+    const results = axe.runVirtualRule('button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
diff --git a/test/integration/virtual-rules/input-button-name.js b/test/integration/virtual-rules/input-button-name.js
index 80f03a90d5..b8972de4c2 100644
--- a/test/integration/virtual-rules/input-button-name.js
+++ b/test/integration/virtual-rules/input-button-name.js
@@ -1,6 +1,6 @@
-describe('input-button-name virtual-rule', function () {
-  it('should pass for type=submit without value', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+describe('input-button-name virtual-rule', () => {
+  it('should pass for type=submit without value', () => {
+    const results = axe.runVirtualRule('input-button-name', {
       nodeName: 'input',
       attributes: {
         type: 'submit'
@@ -12,8 +12,8 @@ describe('input-button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for value', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should pass for value', () => {
+    const results = axe.runVirtualRule('input-button-name', {
       nodeName: 'input',
       attributes: {
         type: 'button',
@@ -26,8 +26,8 @@ describe('input-button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for aria-label', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should pass for aria-label', () => {
+    const results = axe.runVirtualRule('input-button-name', {
       nodeName: 'input',
       attributes: {
         type: 'button',
@@ -40,22 +40,25 @@ describe('input-button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should incomplete for aria-labelledby', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should incomplete for aria-labelledby', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button',
         'aria-labelledby': 'foobar'
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 0);
     assert.lengthOf(results.incomplete, 1);
   });
 
-  it('should pass for title', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should pass for title', () => {
+    const results = axe.runVirtualRule('input-button-name', {
       nodeName: 'input',
       attributes: {
         type: 'button',
@@ -68,8 +71,8 @@ describe('input-button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for role=presentation when disabled', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should pass for role=presentation when disabled', () => {
+    const results = axe.runVirtualRule('input-button-name', {
       nodeName: 'input',
       attributes: {
         type: 'button',
@@ -83,8 +86,8 @@ describe('input-button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for role=none when disabled', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should pass for role=none when disabled', () => {
+    const results = axe.runVirtualRule('input-button-name', {
       nodeName: 'input',
       attributes: {
         type: 'button',
@@ -98,97 +101,159 @@ describe('input-button-name virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when no other attributes are passed', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should pass for implicit label', function () {
+    const node = new axe.SerialVirtualNode({
+      nodeName: 'input',
+      attributes: {
+        type: 'button'
+      }
+    });
+    const parent = new axe.SerialVirtualNode({
+      nodeName: 'label'
+    });
+    const child = new axe.SerialVirtualNode({
+      nodeName: '#text',
+      nodeType: 3,
+      nodeValue: 'foobar'
+    });
+    node.parent = parent;
+    node.children = [];
+    parent.children = [child, node];
+
+    const results = axe.runVirtualRule('input-button-name', node);
+
+    assert.lengthOf(results.passes, 1);
+    assert.lengthOf(results.violations, 0);
+    assert.lengthOf(results.incomplete, 0);
+  });
+
+  it('should incomplete for explicit label', function () {
+    const node = new axe.SerialVirtualNode({
+      nodeName: 'input',
+      attributes: {
+        type: 'button'
+      }
+    });
+
+    const results = axe.runVirtualRule('input-button-name', node);
+
+    assert.lengthOf(results.passes, 0);
+    assert.lengthOf(results.violations, 0);
+    assert.lengthOf(results.incomplete, 1);
+  });
+
+  it('should fail when no other attributes are passed', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button'
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when value is empty', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should fail when value is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button',
         value: ''
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when alt contains only whitespace', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should fail when alt contains only whitespace', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button',
         alt: ' \t   \n   '
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when aria-label is empty', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should fail when aria-label is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button',
         'aria-label': ''
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when title is empty', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should fail when title is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button',
         title: ''
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for role=presentation', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should fail for role=presentation', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button',
         role: 'presentation'
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for role=none', function () {
-    var results = axe.runVirtualRule('input-button-name', {
+  it('should fail for role=none', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'button',
         role: 'none'
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-button-name', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
diff --git a/test/integration/virtual-rules/input-image-alt.js b/test/integration/virtual-rules/input-image-alt.js
index e2b5d48f23..27d8cd1aca 100644
--- a/test/integration/virtual-rules/input-image-alt.js
+++ b/test/integration/virtual-rules/input-image-alt.js
@@ -1,6 +1,6 @@
-describe('input-image-alt virtual-rule', function () {
-  it('should pass for alt', function () {
-    var results = axe.runVirtualRule('input-image-alt', {
+describe('input-image-alt virtual-rule', () => {
+  it('should pass for alt', () => {
+    const results = axe.runVirtualRule('input-image-alt', {
       nodeName: 'input',
       attributes: {
         type: 'image',
@@ -13,8 +13,8 @@ describe('input-image-alt virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should pass for aria-label', function () {
-    var results = axe.runVirtualRule('input-image-alt', {
+  it('should pass for aria-label', () => {
+    const results = axe.runVirtualRule('input-image-alt', {
       nodeName: 'input',
       attributes: {
         type: 'image',
@@ -27,22 +27,25 @@ describe('input-image-alt virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should incomplete for aria-labelledby', function () {
-    var results = axe.runVirtualRule('input-image-alt', {
+  it('should incomplete for aria-labelledby', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'image',
         'aria-labelledby': 'foobar'
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-image-alt', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 0);
     assert.lengthOf(results.incomplete, 1);
   });
 
-  it('should pass for title', function () {
-    var results = axe.runVirtualRule('image-alt', {
+  it('should pass for title', () => {
+    const results = axe.runVirtualRule('image-alt', {
       nodeName: 'img',
       attributes: {
         title: 'foobar'
@@ -54,55 +57,108 @@ describe('input-image-alt virtual-rule', function () {
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when alt is missing', function () {
-    var results = axe.runVirtualRule('input-image-alt', {
+  it('should pass for implicit label', () => {
+    const node = new axe.SerialVirtualNode({
+      nodeName: 'input',
+      attributes: {
+        type: 'image'
+      }
+    });
+    const parent = new axe.SerialVirtualNode({
+      nodeName: 'label'
+    });
+    const child = new axe.SerialVirtualNode({
+      nodeName: '#text',
+      nodeType: 3,
+      nodeValue: 'foobar'
+    });
+    node.parent = parent;
+    node.children = [];
+    parent.children = [child, node];
+
+    const results = axe.runVirtualRule('input-image-alt', node);
+
+    assert.lengthOf(results.passes, 1);
+    assert.lengthOf(results.violations, 0);
+    assert.lengthOf(results.incomplete, 0);
+  });
+
+  it('should incomplete for explicit label', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'image'
       }
     });
 
+    const results = axe.runVirtualRule('input-image-alt', node);
+
+    assert.lengthOf(results.passes, 0);
+    assert.lengthOf(results.violations, 0);
+    assert.lengthOf(results.incomplete, 1);
+  });
+
+  it('should fail when alt is missing', () => {
+    const node = new axe.SerialVirtualNode({
+      nodeName: 'input',
+      attributes: {
+        type: 'image'
+      }
+    });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-image-alt', node);
+
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when alt is empty', function () {
-    var results = axe.runVirtualRule('input-image-alt', {
+  it('should fail when alt is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'image',
         alt: ''
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-image-alt', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when aria-label is empty', function () {
-    var results = axe.runVirtualRule('input-image-alt', {
+  it('should fail when aria-label is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'image',
         'aria-label': ''
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-image-alt', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);
     assert.lengthOf(results.incomplete, 0);
   });
 
-  it('should fail when title is empty', function () {
-    var results = axe.runVirtualRule('input-image-alt', {
+  it('should fail when title is empty', () => {
+    const node = new axe.SerialVirtualNode({
       nodeName: 'input',
       attributes: {
         type: 'image',
         title: ''
       }
     });
+    node.parent = null;
+
+    const results = axe.runVirtualRule('input-image-alt', node);
 
     assert.lengthOf(results.passes, 0);
     assert.lengthOf(results.violations, 1);