Add isNotDisabled assertion

API.md

@@ -95,6 +95,40 @@ Assert that the [HTMLElement][] or an [HTMLElement][] matching the
 assert.dom('input.active').isNotChecked();
 ```
 
+### isDisabled
+
+-   **See: [#isNotDisabled](#isnotdisabled)**
+
+Assert that the [HTMLElement][] or an [HTMLElement][] matching the
+`selector` is disabled.
+
+**Parameters**
+
+-   `message` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?**
+
+**Examples**
+
+```javascript
+assert.dom('input').isDisabled();
+```
+
+### isNotDisabled
+
+-   **See: [#isDisabled](#isdisabled)**
+
+Assert that the [HTMLElement][] or an [HTMLElement][] matching the
+`selector` is currently not disabled.
+
+**Parameters**
+
+-   `message` **[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)?**
+
+**Examples**
+
+```javascript
+assert.dom('input').isNotDisabled();
+```
+
 ### isFocused
 
 -   **See: [#isNotFocused](#isnotfocused)**

lib/__tests__/is-not-disabled.js

@@ -0,0 +1,138 @@
+/* eslint-env jest */
+
+import TestAssertions from "../helpers/test-assertions";
+
+describe('assert.dom(...).isNotDisabled()', () => {
+  let assert;
+
+  beforeEach(() => {
+    assert = new TestAssertions();
+  });
+
+  test('with custom message', () => {
+    document.body.innerHTML = '<input type="text" disabled>';
+
+    assert.dom('input').isNotDisabled('custom message');
+
+    expect(assert.results).toEqual([{
+      actual: 'Element input is disabled',
+      expected: 'Element input is not disabled',
+      message: 'custom message',
+      result: false,
+    }]);
+  });
+
+  describe('with HTMLElement', () => {
+    let element;
+
+    beforeEach(() => {
+      document.body.innerHTML = '<input type="text">';
+      element = document.querySelector('input');
+    });
+
+    test('succeeds if element is not disabled', () => {
+      assert.dom(element).isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        actual: 'Element input[type=\"text\"] is not disabled',
+        expected: 'Element input[type=\"text\"] is not disabled',
+        message: 'Element input[type=\"text\"] is not disabled',
+        result: true,
+      }]);
+    });
+
+    test('fails if element is disabled', () => {
+      element.disabled = true;
+      assert.dom(element).isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        actual: 'Element input[type=\"text\"][disabled] is disabled',
+        expected: 'Element input[type=\"text\"][disabled] is not disabled',
+        message: 'Element input[type=\"text\"][disabled] is not disabled',
+        result: false,
+      }]);
+    });
+
+    test('fails for missing element', () => {
+      assert.dom(null).isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        message: 'Element <unknown> exists',
+        result: false,
+      }]);
+    });
+
+    test('fails if element is disabled with text', () => {
+      document.body.innerHTML = '<input type="text" disabled="false">';
+      element = document.querySelector('input');
+
+      assert.dom('input').isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        actual: 'Element input is disabled',
+        expected: 'Element input is not disabled',
+        message: 'Element input is not disabled',
+        result: false,
+      }]);
+    });
+  });
+
+  describe('with selector', () => {
+    beforeEach(() => {
+      document.body.innerHTML = '<input type="text">';
+    });
+
+    test('succeeds if element is not disabled', () => {
+      assert.dom('input').isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        actual: 'Element input is not disabled',
+        expected: 'Element input is not disabled',
+        message: 'Element input is not disabled',
+        result: true,
+      }]);
+    });
+
+    test('fails if element is disabled', () => {
+      document.querySelector('input').disabled = true;
+      assert.dom('input').isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        actual: 'Element input is disabled',
+        expected: 'Element input is not disabled',
+        message: 'Element input is not disabled',
+        result: false,
+      }]);
+    });
+
+    test('fails for missing element', () => {
+      assert.dom('input[type="password"]').isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        message: 'Element input[type="password"] exists',
+        result: false,
+      }]);
+    });
+
+    test('fails if element is disabled with text', () => {
+      document.body.innerHTML = '<input type="text" disabled="false">';
+      assert.dom('input').isNotDisabled();
+
+      expect(assert.results).toEqual([{
+        actual: 'Element input is disabled',
+        expected: 'Element input is not disabled',
+        message: 'Element input is not disabled',
+        result: false,
+      }]);
+    });
+  });
+
+  test('throws for unexpected parameter types', () => {
+    expect(() => assert.dom(5).isNotDisabled()).toThrow('Unexpected Parameter: 5');
+    expect(() => assert.dom(true).isNotDisabled()).toThrow('Unexpected Parameter: true');
+    expect(() => assert.dom(undefined).isNotDisabled()).toThrow('Unexpected Parameter: undefined');
+    expect(() => assert.dom({}).isNotDisabled()).toThrow('Unexpected Parameter: [object Object]');
+    expect(() => assert.dom(document).isNotDisabled()).toThrow('Unexpected Parameter: [object HTMLDocument]');
+    expect(() => assert.dom(document.createElement('div')).isNotDisabled()).toThrow('Unexpected Element Type: [object HTMLDivElement]');
+  });
+});

lib/assertions.js

@@ -7,6 +7,7 @@ import isRequired from './assertions/is-required';
 import isNotRequired from './assertions/is-not-required';
 import isVisible from './assertions/is-visible';
 import isNotVisible from './assertions/is-not-visible';
+import isNotDisabled from './assertions/is-not-disabled';
 
 import elementToString from './helpers/element-to-string';
 import collapseWhitespace from './helpers/collapse-whitespace';
@@ -268,6 +269,20 @@ export default class DOMAssertions {
     this.pushResult({ result, actual, expected, message });
   }
 
+  /**
+   *  Assert that the [HTMLElement][] or an [HTMLElement][] matching the
+   * `selector` is not disabled.
+   *
+   * @param {string?} message
+   *
+   * @example
+   * assert.dom('.foo').isNotDisabled();
+   *
+   */
+  isNotDisabled(message) {
+    isNotDisabled.call(this, message);
+  }
+
   /**
    * Assert that the [HTMLElement][] has no attribute with the provided `name`.
    *

lib/assertions/is-not-disabled.js

@@ -0,0 +1,26 @@
+export default function notDisabled(message) {
+  let element = this.findTargetElement();
+  if (!element) return;
+
+  if (!(
+    element instanceof HTMLInputElement ||
+    element instanceof HTMLTextAreaElement ||
+    element instanceof HTMLSelectElement ||
+    element instanceof HTMLButtonElement ||
+    element instanceof HTMLOptGroupElement ||
+    element instanceof HTMLOptionElement ||
+    element instanceof HTMLFieldSetElement
+  )) {
+    throw new TypeError(`Unexpected Element Type: ${element.toString()}`);
+  }
+
+  let result = element.disabled === false;
+  let actual = result ? `Element ${this.targetDescription} is not disabled` : `Element ${this.targetDescription} is disabled`;
+  let expected = `Element ${this.targetDescription} is not disabled`;
+
+  if (!message) {
+    message = expected;
+  }
+
+  this.pushResult({ result, actual, expected, message });
+}