Tighter null checks

packages/qunit-dom/lib/__tests__/does-not-exist.ts

@@ -54,6 +54,21 @@ describe('assert.dom(...).doesNotExist()', () => {
         },
       ]);
     });
+
+    test('fails if passed null', () => {
+      document.body.innerHTML = '<h1 class="baz">foo</h1>bar';
+
+      assert.dom(null).doesNotExist();
+
+      expect(assert.results).toEqual([
+        {
+          actual: 'Element <not found> does not exist',
+          expected: 'Element <not found> does not exist',
+          message: 'Element <not found> does not exist',
+          result: true,
+        },
+      ]);
+    });
   });
 
   test('custom message', () => {

packages/qunit-dom/lib/__tests__/does-not-have-attribute.ts

@@ -83,6 +83,17 @@ describe('assert.dom(...).doesNotHaveAttribute()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).doesNotHaveAttribute('disabled');
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).doesNotHaveAttribute('disabled')).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/does-not-have-class.ts

@@ -117,6 +117,17 @@ describe('assert.dom(...).doesNotHaveClass()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).doesNotHaveClass('foo');
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).doesNotHaveClass('foo')).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/does-not-have-style.ts

@@ -90,6 +90,18 @@ describe('assert.dom(...).doesNotHaveStyle()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).doesNotHaveStyle({
+      opacity: 0,
+    });
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).doesNotHaveStyle({ opacity: 1 })).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/does-not-match-selector.ts

@@ -82,6 +82,21 @@ describe('assert.dom(...).doesNotMatchSelector()', () => {
       ]);
     });
 
+    test('null passed', () => {
+      assert.dom(null).doesNotMatchSelector('div>p:last-child');
+
+      expect(assert.results).toEqual([
+        {
+          actual: '0 elements, selected by null, did not also match the selector div>p:last-child.',
+          expected:
+            '0 elements, selected by null, did not also match the selector div>p:last-child.',
+          message:
+            '0 elements, selected by null, did not also match the selector div>p:last-child.',
+          result: true,
+        },
+      ]);
+    });
+
     test('multiple elements, some matching compareSelector', () => {
       assert.dom('p').doesNotMatchSelector('div>p');
 

packages/qunit-dom/lib/__tests__/has-any-text.ts

@@ -64,6 +64,17 @@ describe('assert.dom(...).hasAnyText()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasAnyText();
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasAnyText()).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-any-value.ts

@@ -65,6 +65,17 @@ describe('assert.dom(...).hasAnyValue()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasAnyValue();
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasAnyValue()).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-attribute.ts

@@ -238,6 +238,17 @@ describe('assert.dom(...).hasAttribute()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasAttribute('foo');
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasAttribute('foo')).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-class.ts

@@ -112,6 +112,17 @@ describe('assert.dom(...).hasClass()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasClass('foo');
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasClass('foo')).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-no-text.ts

@@ -62,6 +62,17 @@ describe('assert.dom(...).hasNoText()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasNoText();
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasNoText()).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-no-value.ts

@@ -64,6 +64,17 @@ describe('assert.dom(...).hasNoValue()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasNoValue();
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasNoValue()).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-property.ts

@@ -150,6 +150,17 @@ describe('assert.dom(...).hasProperty()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasProperty('foo', 'bar');
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasProperty('foo', 'bar')).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-style.ts

@@ -108,6 +108,18 @@ describe('assert.dom(...).hasStyle()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasStyle({
+      opacity: 0,
+    });
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasStyle({ opacity: 1 })).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/has-value.ts

@@ -221,6 +221,17 @@ describe('assert.dom(...).hasValue()', () => {
     ]);
   });
 
+  test('fails for null', () => {
+    assert.dom(null).hasValue('foo');
+
+    expect(assert.results).toEqual([
+      {
+        message: 'Element <unknown> should exist',
+        result: false,
+      },
+    ]);
+  });
+
   test('throws for unexpected parameter types', () => {
     //@ts-ignore -- These assertions are for JavaScript users who don't have type checking
     expect(() => assert.dom(5).hasValue('foo')).toThrow('Unexpected Parameter: 5');

packages/qunit-dom/lib/__tests__/is-not-visible.ts

@@ -34,6 +34,23 @@ describe('assert.dom(...).isNotVisible()', () => {
     });
   });
 
+  describe('element only', () => {
+    test('succeeds if element is missing', () => {
+      document.body.innerHTML = '<h1 class="baz">foo</h1>bar';
+
+      assert.dom(null).isNotVisible();
+
+      expect(assert.results).toEqual([
+        {
+          actual: 'Element <not found> is not visible',
+          expected: 'Element <not found> is not visible',
+          message: 'Element <not found> is not visible',
+          result: true,
+        },
+      ]);
+    });
+  });
+
   describe('custom messages', () => {
     test('shows custom messages', () => {
       document.body.innerHTML = '<h1 class="baz">foo</h1>bar';

packages/qunit-dom/lib/__tests__/matches-selector.ts

@@ -82,6 +82,19 @@ describe('assert.dom(...).matchesSelector()', () => {
       ]);
     });
 
+    test('null passed', () => {
+      assert.dom(null).matchesSelector('div>p:last-child');
+
+      expect(assert.results).toEqual([
+        {
+          actual: '0 elements, selected by null, also match the selector div>p:last-child.',
+          expected: '0 elements, selected by null, also match the selector div>p:last-child.',
+          message: '0 elements, selected by null, also match the selector div>p:last-child.',
+          result: true,
+        },
+      ]);
+    });
+
     test('multiple elements not all matching compareSelector', () => {
       assert.dom('p').matchesSelector('p + p');