diff --git a/documentation/assertions/DOMElement/to-contain.md b/documentation/assertions/DOMElement/to-contain.md
new file mode 100644
index 00000000..4f0664d7
--- /dev/null
+++ b/documentation/assertions/DOMElement/to-contain.md
@@ -0,0 +1,89 @@
+Assert that an element contains descendant elements satisfying a given specification.
+
+```js
+var element = createElement(`
+  <section>
+    <h1 class='title' data-test-id='title'>Assert on text content</h1>
+    <p>
+      Learn about howto assert on the text content of a DOM element.
+    </p>
+    <p data-test-id='learn'>
+      Learn more <a href='https://example.com/learn'>here</a>.
+    </p>
+  </section>
+`);
+```
+
+Expect that an element contains a subtree satisfying a HTML fragment given as
+string:
+
+```js
+expect(element, 'to contain', '<h1>Assert on text content</h1>');
+```
+
+You can also assert against a DOM element:
+
+```js
+expect(element, 'to contain', createElement('<h1>Assert on text content</h1>'));
+```
+
+Finally you can also use the full power of [to
+satisfy](http://unexpected.js.org/assertions/any/to-satisfy/) where you provide
+the subtree you expect the subject to contain:
+
+```js
+expect(element, 'to contain', {
+  children: [
+    /^Learn/,
+    {
+      name: 'a',
+      attributes: {
+        href: 'https://example.com/learn'
+      },
+      children: ['here']
+    },
+    '.'
+  ]
+});
+```
+
+When the assertion fails you get a nice descriptive error:
+
+```js
+expect(element, 'to contain', '<h1 class="heading">Assert on all content</h1>');
+```
+
+```output
+expected
+<section>
+  <h1 class="title" data-test-id="title">
+    Assert on text content
+  </h1>
+  <p>
+    Learn about howto assert on the text content of a DOM element.
+  </p>
+  <p data-test-id="learn">
+    Learn more
+    <a href="https://example.com/learn">...</a>
+    .
+  </p>
+</section>
+to contain <h1 class="heading">Assert on all content</h1>
+
+<h1
+  class="title" // expected [ 'title' ] to contain 'heading'
+  data-test-id="title"
+>
+  Assert on text content // should equal 'Assert on all content'
+                         //
+                         // -Assert on text content
+                         // +Assert on all content
+</h1>
+```
+
+You can also assert that the element has no descendant elements satisfying the
+given specification:
+
+```js
+expect(element, 'not to contain', '<h1 class="heading">Assert on all content</h1>');
+```
diff --git a/documentation/assertions/DOMNodeList/to-contain.md b/documentation/assertions/DOMNodeList/to-contain.md
new file mode 100644
index 00000000..59bec06d
--- /dev/null
+++ b/documentation/assertions/DOMNodeList/to-contain.md
@@ -0,0 +1,69 @@
+Assert that a DOM node list contains elements satisfying a given specification.
+
+See [to contain](../../DOMElement/to-contain/) for more details.
+
+```js
+var element = createElement(`
+  <section>
+    <h1>Numbers</h1>
+    <hr>
+    <ol data-test-id="numbers">
+      <li class="number">One</li>
+      <li class="number">Two</li>
+      <li class="number">Three</li>
+    </ol>
+  </section>
+`);
+
+expect(element, 'queried for', 'li', 'to contain', '<li>One</li>');
+
+expect(element, 'to contain', { textContent: 'Three' });
+
+expect(element, 'to contain', { name: 'li', textContent: /One|Two|Tree/ });
+```
+
+In case of a failing expectation you get the following output:
+
+```js
+expect(
+  element,
+  'queried for',
+  'li',
+  'to contain',
+  '<li class="count">Three</li>'
+);
+```
+
+```output
+expected
+<section><h1>Numbers</h1><hr><ol data-test-id="numbers">
+  <li class="number">...</li>
+  <li class="number">...</li>
+  <li class="number">...</li>
+</ol></section>
+queried for li to contain '<li class="count">Three</li>'
+  expected
+  NodeList[
+    <li class="number">One</li>,
+    <li class="number">Two</li>,
+    <li class="number">Three</li>
+  ]
+  to contain <li class="count">Three</li>
+
+  <li
+    class="number" // expected [ 'number' ] to contain 'count'
+  >Three</li>
+```
+
+You can also assert that the element has no descendant elements satisfying the
+given specification:
+
+```js
+expect(
+  element,
+  'queried for',
+  'li',
+  'not to contain',
+  '<li class="count">Three</li>'
+);
+```
diff --git a/src/index.js b/src/index.js
index 56217998..b0d115c7 100644
--- a/src/index.js
+++ b/src/index.js
@@ -253,6 +253,25 @@ function stringifyEndTag(element) {
   }
 }
 
+function ensureSupportedSpecOptions(options) {
+  const unsupportedOptions = Object.keys(options).filter(
+    key =>
+      key !== 'attributes' &&
+      key !== 'name' &&
+      key !== 'children' &&
+      key !== 'onlyAttributes' &&
+      key !== 'textContent'
+  );
+
+  if (unsupportedOptions.length > 0) {
+    throw new Error(
+      `Unsupported option${
+        unsupportedOptions.length === 1 ? '' : 's'
+      }: ${unsupportedOptions.join(', ')}`
+    );
+  }
+}
+
 module.exports = {
   name: 'unexpected-dom',
   installInto(expect) {
@@ -938,21 +957,7 @@ module.exports = {
       '<DOMElement> to [exhaustively] satisfy <object>',
       (expect, subject, value) => {
         const isHtml = isInsideHtmlDocument(subject);
-        const unsupportedOptions = Object.keys(value).filter(
-          key =>
-            key !== 'attributes' &&
-            key !== 'name' &&
-            key !== 'children' &&
-            key !== 'onlyAttributes' &&
-            key !== 'textContent'
-        );
-        if (unsupportedOptions.length > 0) {
-          throw new Error(
-            `Unsupported option${
-              unsupportedOptions.length === 1 ? '' : 's'
-            }: ${unsupportedOptions.join(', ')}`
-          );
-        }
+        ensureSupportedSpecOptions(value);
 
         const promiseByKey = {
           name: expect.promise(() => {
@@ -1447,5 +1452,272 @@ module.exports = {
         return expect.shift(parseXml(subject));
       }
     );
+
+    function scoreElementAgainstSpec(element, spec) {
+      const isTextSimilar = (value, valueSpec) => {
+        const actual = (value || '').trim().toLowerCase();
+        if (typeof valueSpec === 'string') {
+          if (actual === valueSpec.trim().toLowerCase()) {
+            return true;
+          }
+        } else if (valueSpec instanceof RegExp) {
+          if (valueSpec.test(actual)) {
+            return true;
+          }
+        } else if (typeof valueSpec === 'function') {
+          return true;
+        }
+
+        return false;
+      };
+
+      const isHtml = isInsideHtmlDocument(element);
+
+      let score = 0;
+
+      const nodeName = isHtml
+        ? element.nodeName.toLowerCase()
+        : element.nodeName;
+
+      if (isTextSimilar(nodeName, spec.name)) {
+        score++;
+      }
+
+      if (isTextSimilar(element.textContent, spec.textContent)) {
+        score++;
+      }
+
+      if (typeof element.hasAttribute === 'function') {
+        const attributes = spec.attributes || {};
+        const className = attributes['class'];
+        const style = attributes.style;
+
+        if (className && element.hasAttribute('class')) {
+          if (typeof className === 'string') {
+            const expectedClasses = getClassNamesFromAttributeValue(className);
+            const actualClasses = getClassNamesFromAttributeValue(
+              element.getAttribute('class')
+            );
+
+            expectedClasses.forEach(expectedClass => {
+              if (actualClasses.indexOf(expectedClass) !== -1) {
+                score++;
+              }
+            });
+          } else if (isTextSimilar(element.getAttribute('class'), className)) {
+            score++;
+          }
+        }
+
+        if (style && element.hasAttribute('style')) {
+          const expectedStyles =
+            typeof style === 'string' ? styleStringToObject(style) : style;
+          const actualStyles = styleStringToObject(
+            element.getAttribute('style')
+          );
+
+          Object.keys(expectedStyles).forEach(styleName => {
+            const expectedStyle = expectedStyles[styleName];
+            const actualStyle = actualStyles[styleName];
+
+            if (actualStyle) {
+              score++;
+            }
+
+            if (isTextSimilar(actualStyle, expectedStyle)) {
+              score++;
+            }
+          });
+        }
+
+        const specialAttributes = ['style', 'class'];
+        const ids = ['id', 'data-test-id', 'data-testid'];
+
+        Object.keys(attributes).forEach(attributeName => {
+          if (specialAttributes.indexOf(attributeName) !== -1) {
+            return; // skip
+          }
+
+          if (element.hasAttribute(attributeName)) {
+            if (typeof attributes[attributeName] === 'boolean') {
+              score++;
+            }
+
+            if (
+              element.getAttribute(attributeName) === attributes[attributeName]
+            ) {
+              score += ids.indexOf(attributeName) === -1 ? 1 : 100;
+            }
+          } else if (typeof attributes[attributeName] === 'undefined') {
+            score++;
+          }
+        });
+      }
+
+      const expectedChildren = spec.children || [];
+
+      expectedChildren.forEach((childSpec, i) => {
+        const child = element.childNodes[i];
+        const childType = expect.findTypeOf(child);
+
+        if (!child) {
+          return;
+        }
+
+        if (typeof childSpec.nodeType === 'number') {
+          if (child.nodeType === childSpec.nodeType) {
+            if (childType.is('DOMElement')) {
+              // Element
+              score += scoreElementAgainstSpec(
+                element.childNodes[i],
+                convertDOMNodeToSatisfySpec(childSpec)
+              );
+            }
+
+            score++;
+          } else if (expect.findTypeOf(childSpec).is('DOMIgnoreComment')) {
+            score++;
+          }
+        } else if (
+          childType.is('DOMElement') &&
+          typeof childSpec === 'object'
+        ) {
+          score += scoreElementAgainstSpec(element.childNodes[i], childSpec);
+        } else if (
+          childType.is('DOMTextNode') &&
+          isTextSimilar(child.nodeValue, childSpec)
+        ) {
+          score++;
+        }
+      });
+
+      return score;
+    }
+
+    function findMatchesWithGoodScore(data, spec) {
+      const elements =
+        typeof data.length === 'number' ? Array.from(data) : [data];
+
+      const result = [];
+      let bestScore = 0;
+
+      elements.forEach(element => {
+        const score = scoreElementAgainstSpec(element, spec);
+        bestScore = Math.max(score, bestScore);
+
+        if (score > 0 && score >= bestScore) {
+          result.push({ score, element });
+        }
+
+        for (var i = 0; i < element.childNodes.length; i += 1) {
+          const child = element.childNodes[i];
+          if (child.nodeType === 1) {
+            result.push(...findMatchesWithGoodScore(child, spec));
+          }
+        }
+      });
+
+      result.sort((a, b) => b.score - a.score);
+
+      if (result.length > 0) {
+        const bestScore = result[0].score;
+
+        return result.filter(({ score }) => score === bestScore);
+      }
+
+      return result;
+    }
+
+    expect.exportAssertion(
+      '<DOMDocument|DOMElement|DOMDocumentFragment|DOMNodeList> [not] to contain <DOMElement|object|string>',
+      (expect, subject, value) => {
+        const nodes = subject.childNodes || makeAttachedDOMNodeList(subject);
+        const isHtml = isInsideHtmlDocument(
+          subject.childNodes ? subject : nodes
+        );
+        const valueType = expect.findTypeOf(value);
+        let spec = value;
+
+        if (valueType.is('DOMElement')) {
+          spec = convertDOMNodeToSatisfySpec(value, isHtml);
+        } else if (valueType.is('string')) {
+          const documentFragment = isHtml
+            ? parseHtml(value, true)
+            : parseXml(value);
+
+          if (documentFragment.childNodes.length !== 1) {
+            throw new Error(
+              'HTMLElement to contain string: Only a single node is supported'
+            );
+          }
+
+          spec = convertDOMNodeToSatisfySpec(
+            documentFragment.childNodes[0],
+            isHtml
+          );
+
+          if (typeof spec === 'string') {
+            throw new Error(
+              'HTMLElement to contain string: please provide a HTML structure as a string'
+            );
+          }
+
+          expect.argsOutput = output =>
+            output.appendInspected(documentFragment.childNodes[0]);
+
+          ensureSupportedSpecOptions(spec);
+        }
+
+        const scoredElements = findMatchesWithGoodScore(nodes, spec);
+
+        if (expect.flags.not) {
+          if (scoredElements.length > 0) {
+            return expect.withError(
+              () =>
+                expect(
+                  scoredElements.map(({ element }) => element),
+                  'not to have an item satisfying',
+                  spec
+                ),
+              () => {
+                const bestMatch = scoredElements[0].element;
+
+                expect.subjectOutput = output =>
+                  expect.inspect(subject, Infinity, output);
+
+                expect.fail({
+                  diff: (output, diff, inspect, equal) => {
+                    return output
+                      .error('Found:')
+                      .nl(2)
+                      .appendInspected(bestMatch);
+                  }
+                });
+              }
+            );
+          }
+        } else {
+          if (scoredElements.length === 0) {
+            expect.subjectOutput = output =>
+              expect.inspect(subject, Infinity, output);
+            expect.fail();
+          }
+
+          return expect.withError(
+            () =>
+              expect(
+                scoredElements.map(({ element }) => element),
+                'to have an item satisfying',
+                spec
+              ),
+            () => {
+              const bestMatch = scoredElements[0].element;
+
+              return expect(bestMatch, 'to satisfy', spec);
+            }
+          );
+        }
+      }
+    );
   }
 };
diff --git a/test/index.spec.js b/test/index.spec.js
index ce3b6ff3..0116bb3f 100644
--- a/test/index.spec.js
+++ b/test/index.spec.js
@@ -2858,4 +2858,639 @@ describe('unexpected-dom', () => {
         '></foO>'
     );
   });
+
+  describe('to contain', () => {
+    describe('on a DOMDocument', () => {
+      describe('when given a DOMElement', () => {
+        it('succeeds if the given structure is present', () => {
+          expect(
+            '<!DOCTYPE html><html><body><div><i>Hello</i> <span class="name something-else">Jane Doe</span></div></body></html>',
+            'when parsed as HTML to contain',
+            parseHtmlNode('<span class="name">Jane Doe</span>')
+          );
+        });
+      });
+    });
+
+    describe('on a DOMDocumentFragment', () => {
+      it('succeeds if the given structure is present', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>',
+          'when parsed as HTML fragment to contain',
+          '<span class="name">Jane Doe</span>'
+        );
+      });
+    });
+
+    describe('on a DOMElement', () => {
+      it('succeeds if the given structure is present', () => {
+        expect(
+          parseHtmlNode(
+            '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>'
+          ),
+          'to contain',
+          '<span class="name">Jane Doe</span>'
+        );
+      });
+    });
+
+    describe('on a DOMNodeList', () => {
+      it('succeeds if the given structure is present', () => {
+        expect(
+          '<div>Nothing here</div><div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>',
+          'when parsed as HTML fragment',
+          'queried for',
+          'div',
+          'to contain',
+          '<span class="name">Jane Doe</span>'
+        );
+      });
+    });
+
+    describe('on an XMLDocument', () => {
+      it('succeeds if the given structure is present', () => {
+        expect(
+          '<?xml version="1.0"?><qux><fooBar yes="sir">foo</fooBar> bax <Quux>baax</Quux></qux>',
+          'parsed as XML',
+          'to contain',
+          '<fooBar yes="sir">foo</fooBar>'
+        );
+      });
+    });
+
+    describe('when given a DOMElement', () => {
+      it('succeeds if the given structure is present', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          parseHtmlNode('<span class="name">Jane Doe</span>')
+        );
+      });
+    });
+
+    describe('when given a spec', () => {
+      it('succeeds if the given structure is present', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            name: 'span',
+            attributes: { class: 'name' },
+            textContent: expect.it('to match', /^Jane/).and('to have length', 8)
+          }
+        );
+      });
+
+      it('supports searching for class names', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            attributes: { class: 'something-else name' }
+          }
+        );
+      });
+
+      it('supports searching for inline-styles by an object', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else" style="background-color: red; color: green">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            attributes: { style: { 'background-color': 'red' } }
+          }
+        );
+      });
+
+      it('supports searching for inline-styles by a string', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else" style="background-color: red; color: green">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            attributes: { style: 'background-color: red' }
+          }
+        );
+      });
+
+      it('supports using regexps on the tag name', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else" style="background-color: red; color: green">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            name: /^(i|span)$/,
+            textContent: 'Hello'
+          }
+        );
+      });
+
+      it('supports using expect.it on the tag name', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else" style="background-color: red; color: green">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            name: expect.it('to have length', 1),
+            textContent: 'Hello'
+          }
+        );
+      });
+
+      it('supports using regexps on the class name', () => {
+        expect(
+          '<div><i class="greeting">Hello</i> <span class="name something-else" style="background-color: red; color: green">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            attributes: {
+              class: /^name something/
+            }
+          }
+        );
+      });
+
+      it('supports using expect.it on the class name', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else" style="background-color: red; color: green">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            attributes: {
+              class: expect.it('to end with', 'else')
+            },
+            textContent: 'Jane Doe'
+          }
+        );
+      });
+
+      it('supports using declaring that the class should be undefined', () => {
+        expect(
+          '<div><i class="wat">Hello!</i> <i>Hello</i></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            attributes: {
+              class: undefined
+            },
+            textContent: 'Hello'
+          }
+        );
+      });
+
+      it('supports searching for boolean attributes', () => {
+        expect(
+          '<div><i class="greeting">Hello</i> <span class="name something-else and-this">Jane Doe</span> <input type="checkbox" checked="checked"></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            name: 'input',
+            attributes: { checked: true }
+          }
+        );
+      });
+
+      it('supports searching for false boolean attributes', () => {
+        expect(
+          '<div><input type="checkbox"></div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            name: 'input',
+            attributes: { checked: undefined }
+          }
+        );
+      });
+
+      it('supports searching for a child element', () => {
+        expect(
+          '<div><span class="greeting"><i>Hello</i><!-- comment --></span> Jane Doe</div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            name: 'span',
+            children: [
+              parseHtmlNode('<i>Hello</i>'),
+              parseHtmlNode('<!-- comment -->')
+            ]
+          }
+        );
+      });
+
+      it('supports the onlyAttributes flag', () => {
+        expect(
+          '<div><span class="greeting">Hello</span> Jane Doe</div>',
+          'when parsed as HTML',
+          'to contain',
+          {
+            name: 'span',
+            attributes: {
+              class: 'greeting'
+            },
+            onlyAttributes: true
+          }
+        );
+      });
+    });
+
+    describe('when given a string', () => {
+      it('succeeds if the given structure is present', () => {
+        expect(
+          '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>',
+          'when parsed as HTML',
+          'to contain',
+          '<span class="name">Jane Doe</span>'
+        );
+      });
+
+      it('fails when given more than on node', () => {
+        expect(
+          () => {
+            expect(
+              '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>',
+              'when parsed as HTML',
+              'to contain',
+              '<span class="name">Jane Doe</span>!'
+            );
+          },
+          'to throw',
+          'HTMLElement to contain string: Only a single node is supported'
+        );
+      });
+    });
+
+    it('supports only stating a subset of the classes', () => {
+      expect(
+        '<div><i class="greeting">Hello</i> <span class="name something-else and-this">Jane Doe</span></div>',
+        'when parsed as HTML',
+        'to contain',
+        '<span class="name and-this">Jane Doe</span>'
+      );
+    });
+
+    it('supports searching for boolean attributes', () => {
+      expect(
+        '<div><i class="greeting">Hello</i> <span class="name something-else and-this">Jane Doe</span> <input type="checkbox" checked="checked"></div>',
+        'when parsed as HTML',
+        'to contain',
+        '<input type="checkbox" checked="checked">'
+      );
+    });
+
+    it('supports searching for style values', () => {
+      expect(
+        '<div><i style="color: red">Hello</i> <span style="color: blue: background: #bad5aa">Jane Doe</span><em style="background: orange">!</em></div>',
+        'when parsed as HTML',
+        'to contain',
+        '<span style="color: blue">Jane Doe</span>'
+      );
+    });
+
+    it('takes ignore comments into account when searching children', () => {
+      expect(
+        '<div><span class="greeting"><span>Hello</span><span class="name">Jane Doe</span></span></div>',
+        'when parsed as HTML',
+        'to contain',
+        '<span><span>Hello</span><!--ignore--></span>'
+      );
+    });
+
+    it('fails searching for a plain string', () => {
+      expect(
+        () => {
+          expect(
+            '<div><span class="greeting"><span>Hello</span><span class="name">Jane Doe</span></span></div>',
+            'when parsed as HTML',
+            'to contain',
+            'Jane Doe'
+          );
+        },
+        'to throw',
+        'HTMLElement to contain string: please provide a HTML structure as a string'
+      );
+    });
+
+    it('fails when matching against an element with no children', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode('<div></div>'),
+            'to contain',
+            '<span>Jane Doe</span>'
+          );
+        },
+        'to throw',
+        'expected <div></div> to contain <span>Jane Doe</span>'
+      );
+    });
+
+    it('should not match directly on the subject', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<span class="greeting"><span>Hello</span><span class="name">Jane Doe</span></span>'
+            ),
+            'to contain',
+            '<span><span>Hello</span><!--ignore--></span>'
+          );
+        },
+        'to throw',
+        'expected\n' +
+          '<span class="greeting">\n' +
+          '  <span>Hello</span>\n' +
+          '  <span class="name">Jane Doe</span>\n' +
+          '</span>\n' +
+          'to contain <span><span>Hello</span><!--ignore--></span>\n' +
+          '\n' +
+          '<span>\n' +
+          "  // missing { name: 'span', attributes: {}, children: [ 'Hello' ] }\n" +
+          '  Hello\n' +
+          '</span>'
+      );
+    });
+
+    it('fails without a diff if no good candidates can be found in the given structure', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><div><div><div><div><div></div></div></div></div></div></div>'
+            ),
+            'to contain',
+            '<span class="name">John Doe</span>'
+          );
+        },
+        'to throw',
+        'expected <div><div><div><div><div><div></div></div></div></div></div></div>\n' +
+          'to contain <span class="name">John Doe</span>'
+      );
+    });
+
+    it('fails with a diff if the given structure is not present', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><i>Hello</i> <span class="name something-else">Jane Doe</span></div>'
+            ),
+            'to contain',
+            '<span class="name">John Doe</span>'
+          );
+        },
+        'to throw',
+        'expected\n' +
+          '<div>\n' +
+          '  <i>Hello</i>\n' +
+          '  \n' +
+          '  <span class="name something-else">Jane Doe</span>\n' +
+          '</div>\n' +
+          'to contain <span class="name">John Doe</span>\n' +
+          '\n' +
+          '<span class="name something-else">\n' +
+          "  Jane Doe // should equal 'John Doe'\n" +
+          '           //\n' +
+          '           // -Jane Doe\n' +
+          '           // +John Doe\n' +
+          '</span>'
+      );
+    });
+
+    it('allows tag names to be different while finding the best match', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><i>Hello</i> <span class="name something-else">Jane Doe</span> and <div>John Doe</div></div>'
+            ),
+            'to contain',
+            '<div class="name">Jane Doe</div>'
+          );
+        },
+        'to throw',
+        'expected\n' +
+          '<div>\n' +
+          '  <i>Hello</i>\n' +
+          '  \n' +
+          '  <span class="name something-else">Jane Doe</span>\n' +
+          '  and\n' +
+          '  <div>John Doe</div>\n' +
+          '</div>\n' +
+          'to contain <div class="name">Jane Doe</div>\n' +
+          '\n' +
+          "<span // should equal 'div'\n" +
+          '  class="name something-else"\n' +
+          '>Jane Doe</span>'
+      );
+    });
+
+    it('matches on sub-trees when searching for the best match', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><i>Hello</i> <span class="name something-else"><em>Jane Doe</em></span> and <div>John Doe</div></div>'
+            ),
+            'to contain',
+            '<span class="name"><i>Jane Doe</i></span>'
+          );
+        },
+        'to throw',
+        'expected\n' +
+          '<div>\n' +
+          '  <i>Hello</i>\n' +
+          '  \n' +
+          '  <span class="name something-else"><em>...</em></span>\n' +
+          '  and\n' +
+          '  <div>John Doe</div>\n' +
+          '</div>\n' +
+          'to contain <span class="name"><i>Jane Doe</i></span>\n' +
+          '\n' +
+          '<span class="name something-else">\n' +
+          "  <em // should equal 'i'\n" +
+          '  >Jane Doe</em>\n' +
+          '</span>'
+      );
+    });
+
+    it('matches more strongly on ids when showing the best match', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><i>Hello</i> <span data-test-id="name" class="name something-else">Jane Doe</span> and <span class="name">John Doe</span></div>'
+            ),
+            'to contain',
+            '<span data-test-id="name">John Doe</span>'
+          );
+        },
+        'to throw',
+        'expected\n' +
+          '<div>\n' +
+          '  <i>Hello</i>\n' +
+          '  \n' +
+          '  <span class="name something-else" data-test-id="name">\n' +
+          '    Jane Doe\n' +
+          '  </span>\n' +
+          '  and\n' +
+          '  <span class="name">John Doe</span>\n' +
+          '</div>\n' +
+          'to contain <span data-test-id="name">John Doe</span>\n' +
+          '\n' +
+          '<span data-test-id="name" class="name something-else">\n' +
+          "  Jane Doe // should equal 'John Doe'\n" +
+          '           //\n' +
+          '           // -Jane Doe\n' +
+          '           // +John Doe\n' +
+          '</span>'
+      );
+    });
+
+    it('fails if the children is expected but the target is empty', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode('<div><span></span></div>'),
+            'to contain',
+            '<span><i>Hello</i></span>'
+          );
+        },
+        'to throw',
+        'expected <div><span></span></div> to contain <span><i>Hello</i></span>\n' +
+          '\n' +
+          '<span>\n' +
+          "  // missing { name: 'i', attributes: {}, children: [ 'Hello' ] }\n" +
+          '</span>'
+      );
+    });
+
+    it('fails if the an ignored child is expected but the target is empty', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode('<div><span></span></div>'),
+            'to contain',
+            '<span><!-- ignore --></span>'
+          );
+        },
+        'to throw',
+        'expected <div><span></span></div> to contain <span><!-- ignore --></span>\n' +
+          '\n' +
+          '<span>\n' +
+          '  // missing <!-- ignore -->\n' +
+          '</span>'
+      );
+    });
+
+    it('fails if more children is expected than what is available in the target', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><span><strong>Hello</strong><em>world</em></span></div>'
+            ),
+            'to contain',
+            '<span><strong>Hello</strong><!-- ignore -->!</span>'
+          );
+        },
+        'to throw',
+        'expected <div><span><strong>...</strong><em>...</em></span></div>\n' +
+          'to contain <span><strong>Hello</strong><!-- ignore -->!</span>\n' +
+          '\n' +
+          '<span>\n' +
+          '  <strong>Hello</strong>\n' +
+          '  <em>world</em>\n' +
+          "  // missing '!'\n" +
+          '</span>'
+      );
+    });
+
+    it('fails if less children is expected than what is available in the target', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><span><strong>Hello</strong><em>world</em>!</span></div>'
+            ),
+            'to contain',
+            '<span><strong>Hello</strong><em>world</em></span>'
+          );
+        },
+        'to throw',
+        'expected <div><span><strong>...</strong><em>...</em>!</span></div>\n' +
+          'to contain <span><strong>Hello</strong><em>world</em></span>\n' +
+          '\n' +
+          '<span>\n' +
+          '  <strong>Hello</strong>\n' +
+          '  <em>world</em>\n' +
+          '  ! // should be removed\n' +
+          '</span>'
+      );
+    });
+  });
+
+  describe('not to contain', () => {
+    it('succeeds if the given structure is not present', () => {
+      expect(
+        parseHtmlNode(
+          '<div><i>Hello</i> <span data-test-id="name" class="name something-else">Jane Doe</span> and <span class="name">John Doe</span></div>'
+        ),
+        'not to contain',
+        '<span data-test-id="name">John Doe</span>'
+      );
+    });
+
+    it("succeeds if the given structure doesn't match any descendant elements at all", () => {
+      expect(
+        parseHtmlNode(
+          '<div><div><div><div><div><div></div></div></div></div></div></div>'
+        ),
+        'not to contain',
+        '<span data-test-id="name">John Doe</span>'
+      );
+    });
+
+    it('succeeds if the element has no children', () => {
+      expect(
+        parseHtmlNode('<div></div>'),
+        'not to contain',
+        '<span>Jane Doe</span>'
+      );
+    });
+
+    it('shows a diff if the given structure is present', () => {
+      expect(
+        () => {
+          expect(
+            parseHtmlNode(
+              '<div><i>Hello</i> <span data-test-id="name" class="name something-else">Jane Doe</span> and <span class="name">John Doe</span></div>'
+            ),
+            'not to contain',
+            '<span data-test-id="name">Jane Doe</span>'
+          );
+        },
+        'to throw',
+        'expected\n' +
+          '<div>\n' +
+          '  <i>Hello</i>\n' +
+          '  \n' +
+          '  <span class="name something-else" data-test-id="name">\n' +
+          '    Jane Doe\n' +
+          '  </span>\n' +
+          '  and\n' +
+          '  <span class="name">John Doe</span>\n' +
+          '</div>\n' +
+          'not to contain <span data-test-id="name">Jane Doe</span>\n' +
+          '\n' +
+          'Found:\n' +
+          '\n' +
+          '<span class="name something-else" data-test-id="name">\n' +
+          '  Jane Doe\n' +
+          '</span>'
+      );
+    });
+  });
 });