Add isChecked and isNotChecked assertions

lib/__tests__/is-checked.js

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

lib/__tests__/is-not-checked.js

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

lib/assertions.js

@@ -1,6 +1,8 @@
 import exists from './assertions/exists';
 import focused from './assertions/focused';
 import notFocused from './assertions/not-focused';
+import isChecked from './assertions/is-checked';
+import isNotChecked from './assertions/is-not-checked';
 
 import elementToString from './helpers/element-to-string';
 import collapseWhitespace from './helpers/collapse-whitespace';
@@ -42,6 +44,36 @@ export default class DOMAssertions {
     exists.call(this, { count: 0 }, message);
   }
 
+  /**
+   * Assert that the [HTMLElement][] or an [HTMLElement][] matching the
+   * `selector` is currently checked.
+   *
+   * @param {string?} message
+   *
+   * @example
+   * assert.dom('input.active').isChecked();
+   *
+   * @see {@link #isNotChecked}
+   */
+  isChecked(message) {
+    isChecked.call(this, message);
+  }
+
+  /**
+   * Assert that the [HTMLElement][] or an [HTMLElement][] matching the
+   * `selector` is currently unchecked.
+   *
+   * @param {string?} message
+   *
+   * @example
+   * assert.dom('input.active').isNotChecked();
+   *
+   * @see {@link #isChecked}
+   */
+  isNotChecked(message) {
+    isNotChecked.call(this, message);
+  }
+
   /**
    * Assert that the [HTMLElement][] or an [HTMLElement][] matching the
    * `selector` is currently focused.

lib/assertions/is-checked.js

@@ -0,0 +1,16 @@
+import elementToString from '../helpers/element-to-string';
+
+export default function checked(message) {
+  let element = this.findTargetElement();
+  if (!element) return;
+
+  let result = element.checked === true;
+  let actual = element.checked === true ? 'checked' : 'not checked';
+  let expected = 'checked';
+
+  if (!message) {
+    message = `Element ${elementToString(this.target)} is checked`;
+  }
+
+  this.pushResult({ result, actual, expected, message });
+}

lib/assertions/is-not-checked.js

@@ -0,0 +1,16 @@
+import elementToString from '../helpers/element-to-string';
+
+export default function notChecked(message) {
+  let element = this.findTargetElement();
+  if (!element) return;
+
+  let result = element.checked === false;
+  let actual = element.checked === true ? 'checked' : 'not checked';
+  let expected = 'not checked';
+
+  if (!message) {
+    message = `Element ${elementToString(this.target)} is not checked`;
+  }
+
+  this.pushResult({ result, actual, expected, message });
+}