Merge isDisabled and isNotDisabled helpers

lib/__tests__/is-disabled.js

@@ -9,64 +9,130 @@ describe('assert.dom(...).isDisabled()', () => {
  assert = new TestAssertions();
  });
 
- describe('input tags', () => {
- test('succeeds when input is disabled', () => {
- document.body.innerHTML = '<input disabled>';
+ test('with custom message', () => {
+ document.body.innerHTML = '<input type="text">';
+
+ assert.dom('input').isDisabled('custom message');
+
+ expect(assert.results).toEqual([{
+ actual: 'Element input is not disabled',
+ expected: 'Element input is disabled',
+ message: 'custom message',
+ result: false,
+ }]);
+ });
+
+ describe('with HTMLElement', () => {
+ let element;
+
+ beforeEach(() => {
+ document.body.innerHTML = '<input type="text" disabled>';
+ element = document.querySelector('input');
+ });
+
+ test('succeeds if element is disabled', () => {
+ assert.dom(element).isDisabled();
+
+ expect(assert.results).toEqual([{
+ actual: 'Element input[type="text"][disabled] is disabled',
+ expected: 'Element input[type="text"][disabled] is disabled',
+ message: 'Element input[type="text"][disabled] is disabled',
+ result: true,
+ }]);
+ });
+
+ test('fails if element is not disabled', () => {
+ element.disabled = false;
+ assert.dom(element).isDisabled();
+
+ expect(assert.results).toEqual([{
+ actual: 'Element input[type="text"] is not disabled',
+ expected: 'Element input[type="text"] is disabled',
+ message: 'Element input[type="text"] is disabled',
+ result: false,
+ }]);
+ });
+
+ test('fails for missing element', () => {
+ assert.dom(null).isDisabled();
+
+ expect(assert.results).toEqual([{
+ message: 'Element <unknown> exists',
+ result: false,
+ }]);
+ });
+
+ test('succeeds if element is disabled with text', () => {
+ document.body.innerHTML = '<input type="text" disabled="false">';
+ element = document.querySelector('input');
 
  assert.dom('input').isDisabled();
- assert.dom(document.querySelector('input')).isDisabled();
 
  expect(assert.results).toEqual([{
  actual: 'Element input is disabled',
  expected: 'Element input is disabled',
  message: 'Element input is disabled',
  result: true,
- }, {
- actual: 'Element input[disabled] is disabled',
- expected: 'Element input[disabled] is disabled',
- message: 'Element input[disabled] is disabled',
- result: true,
  }]);
  });
+ });
 
- test('fails when input is not disabled', () => {
- document.body.innerHTML = '<input>';
+ describe('with selector', () => {
+ beforeEach(() => {
+ document.body.innerHTML = '<input type="text" disabled>';
+ });
 
+ test('succeeds if element is disabled', () => {
  assert.dom('input').isDisabled();
- assert.dom(document.querySelector('input')).isDisabled();
 
  expect(assert.results).toEqual([{
- actual: 'Element input is not disabled',
+ actual: 'Element input is disabled',
  expected: 'Element input is disabled',
  message: 'Element input is disabled',
- result: false,
- }, {
+ result: true,
+ }]);
+ });
+
+ test('fails if element is not disabled', () => {
+ document.querySelector('input').disabled = false;
+ assert.dom('input').isDisabled();
+
+ expect(assert.results).toEqual([{
  actual: 'Element input is not disabled',
  expected: 'Element input is disabled',
  message: 'Element input is disabled',
  result: false,
  }]);
  });
- });
-
- describe('non-disablable elements', () => {
- test('fails when element does not support disabled', () => {
- document.body.innerHTML = '<div id="dis" disabled><div>';
 
-  assert.dom('div#dis').isDisabled();
- assert.dom(document.querySelector('div#dis')).isDisabled();
+ test('fails for missing element', () => {
+ assert.dom('input[type="password"]').isDisabled();
 
  expect(assert.results).toEqual([{
- actual: 'Element div#dis does not support disabled',
- expected: 'Element div#dis is disabled',
- message: 'Element div#dis is disabled',
- result: false,
- }, {
- actual: 'Element div#dis[disabled] does not support disabled',
- expected: 'Element div#dis[disabled] is disabled',
- message: 'Element div#dis[disabled] is disabled',
+ message: 'Element input[type="password"] exists',
  result: false,
  }]);
  });
+
+ test('succeeds if element is disabled with text', () => {
+ document.body.innerHTML = '<input type="text" disabled="false">';
+ assert.dom('input').isDisabled();
+
+ expect(assert.results).toEqual([{
+ actual: 'Element input is disabled',
+ expected: 'Element input is disabled',
+ message: 'Element input is disabled',
+ result: true,
+ }]);
+ });
+ });
+
+ test('throws for unexpected parameter types', () => {
+ expect(() => assert.dom(5).isDisabled()).toThrow('Unexpected Parameter: 5');
+ expect(() => assert.dom(true).isDisabled()).toThrow('Unexpected Parameter: true');
+ expect(() => assert.dom(undefined).isDisabled()).toThrow('Unexpected Parameter: undefined');
+ expect(() => assert.dom({}).isDisabled()).toThrow('Unexpected Parameter: [object Object]');
+ expect(() => assert.dom(document).isDisabled()).toThrow('Unexpected Parameter: [object HTMLDocument]');
+ expect(() => assert.dom(document.createElement('div')).isDisabled()).toThrow('Unexpected Element Type: [object HTMLDivElement]');
  });
 });

lib/assertions.js

@@ -7,7 +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 isDisabled from './assertions/is-disabled';
 
 import elementToString from './helpers/element-to-string';
 import collapseWhitespace from './helpers/collapse-whitespace';
@@ -318,24 +318,7 @@ export default class DOMAssertions {
  * @see {@link #isNotDisabled}
  */
  isDisabled(message) {
- let element = this.findTargetElement();
-
- let expected = `Element ${this.targetDescription} is disabled`;
- let actual = `Element ${this.targetDescription} is disabled`;
- let result = element.disabled;
-
- if (result === false) {
- actual = `Element ${this.targetDescription} is not disabled`;
- } else if(result === undefined) {
- actual = `Element ${this.targetDescription} does not support disabled`;
- result = false;
- }
-
- if (!message) {
- message = expected;
- }
-
- this.pushResult({ result, actual, expected, message });
+ isDisabled.call(this, message);
  }
 
  /**
@@ -351,7 +334,7 @@ export default class DOMAssertions {
  * @see {@link #isDisabled}
  */
  isNotDisabled(message) {
- isNotDisabled.call(this, message);
+ isDisabled.call(this, message, { inverted: true });
  }
 
  /**

lib/assertions/is-disabled.js

@@ -0,0 +1,34 @@
+export default function isDisabled(message, options = {}) {
+ let { inverted } = options;
+
+ 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 === !inverted;
+
+ let actual = element.disabled === false
+ ? `Element ${this.targetDescription} is not disabled`
+ : `Element ${this.targetDescription} is disabled`;
+
+ let expected = inverted
+ ? `Element ${this.targetDescription} is not disabled`
+ : `Element ${this.targetDescription} is disabled`;
+
+ if (!message) {
+ message = expected;
+ }
+
+ this.pushResult({ result, actual, expected, message });
+}