Call the assertions something else, make the unindent explicit

Author: papandreou

lib/indentString.js

@@ -0,0 +1,12 @@
+function indentString(str, indentationWidth = 2) {
+  const indent = ' '.repeat(indentationWidth);
+  return `\n${str.replace(/^.*?$/gm, $0 => {
+    if ($0) {
+      return `${indent}${$0}`;
+    } else {
+      return '';
+    }
+  })}\n`;
+}
+
+module.exports = indentString;

lib/isSimpleObjectTree.js

@@ -0,0 +1,38 @@
+function isSimpleObjectTree(obj, expect) {
+  const seen = new Set();
+  return (function isSimple(obj) {
+    if (seen.has(obj)) {
+      return false; // Circular
+    } else {
+      const type = expect.findTypeOf(obj);
+      if (type.name === 'array') {
+        seen.add(obj);
+        const result = obj.every(isSimple);
+        seen.delete(obj);
+        return result;
+      } else if (type.name === 'object') {
+        seen.add(obj);
+        const result =
+          obj.constructor === Object &&
+          Object.getOwnPropertyNames(obj).every(name => isSimple(obj[name])) &&
+          Object.getOwnPropertySymbols(obj).length === 0;
+        seen.delete(obj);
+        return result;
+      } else {
+        return [
+          'any',
+          'number',
+          'NaN',
+          'boolean',
+          'regexp',
+          'null',
+          'undefined',
+          'string',
+          'Buffer'
+        ].includes(type.name);
+      }
+    }
+  })(obj);
+}
+
+module.exports = isSimpleObjectTree;

lib/stringSnapshot.js

@@ -13,11 +13,12 @@ const { SourceCode } = eslint;
 const ruleFixer = require('eslint/lib/util/rule-fixer');
 const Traverser = require('eslint/lib/util/traverser');
 const SourceCodeFixer = require('eslint/lib/util/source-code-fixer');
-const { encode, decode } = require('../lib/stringSnapshot');
+const indentString = require('./indentString');
+const isSimpleObjectTree = require('./isSimpleObjectTree');
 
 function stringify(obj, indentationWidth, expectForRendering) {
-  if (typeof obj === 'string') {
-    return `\`${encode(obj, indentationWidth)}\``;
+  if (obj.includes('\n')) {
+    return `expect.unindent\`${indentString(obj, indentationWidth)}\``;
   } else {
     expectForRendering.output.indentationWidth = indentationWidth;
     return expectForRendering.inspect(obj).toString('text');
@@ -173,7 +174,8 @@ function ensureAfterBlockIsRegistered() {
       columnNumber,
       status,
       subject,
-      expectForRendering
+      expectForRendering,
+      assertionName
     } of topLevelFixes) {
       const sourceCode = getSourceCode(fileName);
       if (!sourceCode) {
@@ -209,7 +211,6 @@ function ensureAfterBlockIsRegistered() {
           return '';
         }
       }
-
       new Traverser().traverse(sourceCode.ast, {
         enter(node, parent) {
           if (
@@ -230,29 +231,63 @@ function ensureAfterBlockIsRegistered() {
             } else {
               indent = getNodeIndent(node.arguments[1]);
             }
-            const stringifiedSubject = stringify(
-              subject,
-              indentationWidth,
-              expectForRendering
-            ).replace(/\n^(?=[^\n])/gm, `\n${indent}`);
-
-            let fix;
+            const fixes = [];
+            let stringifiedSubject;
+            let newAssertionName = 'to equal snapshot';
+            if (typeof subject === 'string') {
+              stringifiedSubject = stringify(
+                subject,
+                indentationWidth,
+                expectForRendering
+              ).replace(/\n^(?=[^\n])/gm, `\n${indent}`);
+            } else if (isSimpleObjectTree(subject, expectForRendering)) {
+              expectForRendering.output.indentationWidth = indentationWidth;
+              stringifiedSubject = expectForRendering
+                .inspect(subject)
+                .toString('text');
+            } else {
+              newAssertionName = 'to inspect as snapshot';
+              stringifiedSubject = stringify(
+                expectForRendering.inspect(subject).toString('text'),
+                indentationWidth,
+                expectForRendering
+              ).replace(/\n^(?=[^\n])/gm, `\n${indent}`);
+            }
             if (status === 'missing') {
-              fix = ruleFixer.insertTextAfter(
-                node.arguments[node.arguments.length - 1],
-                `, ${stringifiedSubject}`
-              );
+              if (newAssertionName !== assertionName) {
+                fixes.unshift(
+                  ruleFixer.replaceText(
+                    node.arguments[1],
+                    `'${newAssertionName}', ${stringifiedSubject}`
+                  )
+                );
+              } else {
+                fixes.unshift(
+                  ruleFixer.insertTextAfter(
+                    node.arguments[node.arguments.length - 1],
+                    `, ${stringifiedSubject}`
+                  )
+                );
+              }
             } else if (status === 'mismatch') {
-              fix = ruleFixer.replaceText(
-                node.arguments[node.arguments.length - 1],
-                stringifiedSubject
+              if (newAssertionName !== assertionName) {
+                fixes.unshift(
+                  ruleFixer.replaceText(
+                    node.arguments[1],
+                    `'${newAssertionName}'`
+                  )
+                );
+              }
+              fixes.unshift(
+                ruleFixer.replaceText(
+                  node.arguments[node.arguments.length - 1],
+                  stringifiedSubject
+                )
               );
             }
-            if (fix) {
+            if (fixes.length > 0) {
               (fixesByFileName[fileName] =
-                fixesByFileName[fileName] || []).push({
-                fix
-              });
+                fixesByFileName[fileName] || []).push(...fixes);
             }
           }
         }
@@ -263,7 +298,7 @@ function ensureAfterBlockIsRegistered() {
     for (const fileName of Object.keys(fixesByFileName)) {
       var fixResult = SourceCodeFixer.applyFixes(
         getSourceCode(fileName).text,
-        fixesByFileName[fileName]
+        fixesByFileName[fileName].map(fix => ({ fix }))
       );
       if (fixResult.fixed) {
         fixedSourceTextByFileName[fileName] = fixResult.output;
@@ -394,52 +429,6 @@ module.exports = {
   installInto(expect) {
     const expectForRendering = expect.child();
 
-    // Copy of https://github.com/unexpectedjs/unexpected/blob/bf9bb959b85459eee43e550f8dfea43bead2e7b1/lib/createTopLevelExpect.js#L274
-    // so that we get to control the handling of circular references
-    const defaultDepth = 3;
-    expectForRendering.inspect = function(obj, depth, outputOrFormat) {
-      let seen = [];
-      let printOutput = (obj, currentDepth, output) => {
-        const objType = this.findTypeOf(obj);
-        if (
-          currentDepth <= 0 &&
-          objType.is('object') &&
-          !objType.is('expect.it')
-        ) {
-          return output.text('...');
-        }
-
-        seen = seen || [];
-        if (seen.indexOf(obj) !== -1) {
-          throw new Error('Circular references not supported in snapshots');
-        }
-
-        return objType.inspect(obj, currentDepth, output, (v, childDepth) => {
-          output = output.clone();
-          seen.push(obj);
-          if (typeof childDepth === 'undefined') {
-            childDepth = currentDepth - 1;
-          }
-          output = printOutput(v, childDepth, output) || output;
-          seen.pop();
-          return output;
-        });
-      };
-
-      let output =
-        typeof outputOrFormat === 'string'
-          ? this.createOutput(outputOrFormat)
-          : outputOrFormat;
-      output = output || this.createOutput();
-      return (
-        printOutput(
-          obj,
-          typeof depth === 'number' ? depth : defaultDepth,
-          output
-        ) || output
-      );
-    };
-
     expectForRendering.addType({
       name: 'infiniteBuffer',
       base: 'Buffer',
@@ -523,21 +512,22 @@ module.exports = {
     const symbol = Symbol('unexpectedSnapshot');
 
     expect.addAssertion(
-      '<any> to equal snapshot <any?>',
+      '<any> to (equal|inspect as) snapshot <any?>',
       (expect, subject, ...args) => {
+        const assertionName = `to ${expect.alternations[0]} snapshot`;
+        if (expect.alternations[0] === 'inspect as') {
+          subject = expectForRendering.inspect(subject).toString('text');
+        }
         if (args.length === 1) {
-          let value = args[0];
-          if (typeof value === 'string') {
-            value = decode(value);
-          }
           return expect.withError(
             () => {
-              expect(subject, 'to equal', value);
+              expect(subject, 'to equal', args[0]);
             },
             err => {
               topLevelFixes.push({
                 ...expect.context[symbol],
                 subject,
+                assertionName,
                 status: 'mismatch'
               });
               ensureAfterBlockIsRegistered();
@@ -549,6 +539,7 @@ module.exports = {
             topLevelFixes.push({
               ...expect.context[symbol],
               subject,
+              assertionName,
               status: 'missing'
             });
             ensureAfterBlockIsRegistered();
@@ -562,6 +553,8 @@ module.exports = {
       }
     );
 
+    expect.unindent = require('@gustavnikolaj/string-utils').deindent;
+
     expect.hook(function(next) {
       return function unexpectedSnapshot(context, ...rest) {
         if (!context[symbol]) {

lib/unexpected-snapshot.js

@@ -1,52 +1,39 @@
 const expect = require('unexpected').clone();
-const { encode, decode } = require('../lib/stringSnapshot');
+const indentString = require('../lib/indentString');
+const { deindent } = require('@gustavnikolaj/string-utils');
 
 expect.addAssertion('<string> to roundtrip', (expect, subject) => {
-  expect(decode(encode(subject)), 'to equal', subject);
+  expect(deindent(indentString(subject)), 'to equal', subject);
 });
 
 describe('stringSnapshot', () => {
-  describe('encode', () => {
+  describe('indentString', () => {
     it('should indent a single line string', () => {
-      expect(encode('foo', 2), 'to equal', '\n  foo\n');
+      expect(indentString('foo', 2), 'to equal', '\n  foo\n');
     });
 
     it('should indent an empty string', () => {
-      expect(encode('', 2), 'to equal', '\n\n');
+      expect(indentString('', 2), 'to equal', '\n\n');
     });
 
     it('should not indent empty lines', () => {
-      expect(encode('foo\n\nbar', 2), 'to equal', '\n  foo\n\n  bar\n');
+      expect(indentString('foo\n\nbar', 2), 'to equal', '\n  foo\n\n  bar\n');
     });
 
     it('should indent a line containing only spaces', () => {
-      expect(encode('foo\n  \nbar', 2), 'to equal', '\n  foo\n    \n  bar\n');
-    });
-
-    it('should indent a line ending with newline', () => {
-      expect(encode('foo\n', 2), 'to equal', '\n  foo\n\n');
-    });
-  });
-
-  describe('decode', () => {
-    it('should throw if the newline at the start is missing', () => {
       expect(
-        () => decode('blah'),
-        'to throw',
-        'Missing leading newline in snapshot'
+        indentString('foo\n  \nbar', 2),
+        'to equal',
+        '\n  foo\n    \n  bar\n'
       );
     });
 
-    it('should throw if the newline at the end is missing', () => {
-      expect(
-        () => decode('\n  foo'),
-        'to throw',
-        'Missing trailing newline in snapshot'
-      );
+    it('should indent a line ending with newline', () => {
+      expect(indentString('foo\n', 2), 'to equal', '\n  foo\n\n');
     });
   });
 
-  describe('encode + decode', () => {
+  describe('indentString + deindent', () => {
     it('should roundtrip a single line string', () => {
       expect('foo', 'to roundtrip');
     });