modernize property-based tests

Author: ds300

property-based-tests/executeTestCase.ts

@@ -1,5 +1,4 @@
 import * as tmp from "tmp"
-import * as fs from "fs-extra"
 import * as path from "path"
 
 import { spawnSafeSync } from "../src/spawnSafe"
@@ -9,32 +8,51 @@ import { parsePatch } from "../src/patch/parse"
 
 import { TestCase, Files } from "./testCases"
 
+jest.mock("fs-extra", () => {
+  let workingFiles: Files
+
+  function setWorkingFiles(files: Files) {
+    workingFiles = files
+  }
+
+  function getWorkingFiles() {
+    return workingFiles
+  }
+
+  return {
+    setWorkingFiles,
+    getWorkingFiles,
+    ensureDirSync: jest.fn(),
+    readFileSync: jest.fn(path => getWorkingFiles()[path].contents),
+    writeFileSync: jest.fn(
+      (path: string, contents: string, opts?: { mode?: number }) => {
+        getWorkingFiles()[path] = {
+          contents,
+          mode: opts && typeof opts.mode === "number" ? opts.mode : 0o644,
+        }
+      },
+    ),
+    unlinkSync: jest.fn(path => delete getWorkingFiles()[path]),
+    moveSync: jest.fn((from, to) => {
+      getWorkingFiles()[to] = getWorkingFiles()[from]
+      delete getWorkingFiles()[from]
+    }),
+  }
+})
+
 function writeFiles(cwd: string, files: Files): void {
+  const mkdirpSync = require("fs-extra/lib/mkdirs/index.js").mkdirpSync
+  const writeFileSync = require("fs").writeFileSync
   Object.keys(files).forEach(filePath => {
     if (!filePath.startsWith(".git/")) {
-      fs.mkdirpSync(path.join(cwd, path.dirname(filePath)))
-      fs.writeFileSync(path.join(cwd, filePath), files[filePath].contents, {
+      mkdirpSync(path.join(cwd, path.dirname(filePath)))
+      writeFileSync(path.join(cwd, filePath), files[filePath].contents, {
         mode: files[filePath].mode,
       })
     }
   })
 }
 
-let workingFiles: Files
-
-function setWorkingFiles(files: Files) {
-  workingFiles = files
-}
-
-function getWorkingFiles() {
-  return workingFiles
-}
-
-const properReadFileSync = fs.readFileSync
-const properWriteFileSync = fs.writeFileSync
-const properUnlinkSync = fs.unlinkSync
-const properMoveSync = fs.moveSync
-
 function removeLeadingSpaceOnBlankLines(patchFileContents: string): string {
   return patchFileContents
     .split("\n")
@@ -43,104 +61,78 @@ function removeLeadingSpaceOnBlankLines(patchFileContents: string): string {
 }
 
 export function executeTestCase(testCase: TestCase) {
+  const fs = require("fs-extra")
+
   function reportingFailures(f: () => void): void {
     try {
       f()
     } catch (e) {
       console.error("TEST CASE FAILED", {
         testCase,
-        workingFiles: getWorkingFiles(),
+        workingFiles: fs.getWorkingFiles(),
       })
       throw e
     }
   }
 
-  describe("the test case", () => {
-    beforeEach(() => {
-      ;(fs as any).readFileSync = jest.fn(
-        path => getWorkingFiles()[path].contents,
-      )
-      ;(fs as any).writeFileSync = jest.fn(
-        (path: string, contents: string, opts?: { mode?: number }) => {
-          getWorkingFiles()[path] = {
-            contents,
-            mode: opts && typeof opts.mode === "number" ? opts.mode : 0o644,
-          }
-        },
-      )
-      ;(fs as any).unlinkSync = jest.fn(path => delete getWorkingFiles()[path])
-      ;(fs as any).moveSync = jest.fn((from, to) => {
-        getWorkingFiles()[to] = getWorkingFiles()[from]
-        delete getWorkingFiles()[from]
-      })
-    })
+  const tmpDir = tmp.dirSync({ unsafeCleanup: true, mode: 0o100777 })
 
-    afterEach(() => {
-      ;(fs as any).readFileSync = properReadFileSync
-      ;(fs as any).writeFileSync = properWriteFileSync
-      ;(fs as any).unlinkSync = properUnlinkSync
-      ;(fs as any).moveSync = properMoveSync
-    })
+  spawnSafeSync("git", ["init"], { cwd: tmpDir.name })
 
-    const tmpDir = tmp.dirSync({ unsafeCleanup: true, mode: 0o100777 })
+  writeFiles(tmpDir.name, testCase.cleanFiles)
 
-    spawnSafeSync("git", ["init"], { cwd: tmpDir.name })
+  spawnSafeSync("git", ["add", "-A"], { cwd: tmpDir.name })
+  spawnSafeSync("git", ["commit", "-m", "blah"], {
+    cwd: tmpDir.name,
+  })
+  spawnSafeSync("git", ["rm", "-rf", "*"], {
+    cwd: tmpDir.name,
+  })
 
-    writeFiles(tmpDir.name, testCase.cleanFiles)
+  writeFiles(tmpDir.name, testCase.modifiedFiles)
+  spawnSafeSync("git", ["add", "-A"], { cwd: tmpDir.name })
 
-    spawnSafeSync("git", ["add", "-A"], { cwd: tmpDir.name })
-    spawnSafeSync("git", ["commit", "-m", "blah"], {
+  const patchResult = spawnSafeSync(
+    "git",
+    ["diff", "--color=never", "--cached"],
+    {
       cwd: tmpDir.name,
-    })
-    spawnSafeSync("git", ["rm", "-rf", "*"], {
-      cwd: tmpDir.name,
-    })
+      logStdErrOnError: true,
+      throwOnError: true,
+    },
+  )
 
-    writeFiles(tmpDir.name, testCase.modifiedFiles)
-    spawnSafeSync("git", ["add", "-A"], { cwd: tmpDir.name })
+  const patchFileContents = patchResult.stdout.toString()
 
-    const patchResult = spawnSafeSync(
-      "git",
-      ["diff", "--color=never", "--cached"],
-      {
-        cwd: tmpDir.name,
-        logStdErrOnError: true,
-        throwOnError: true,
-      },
-    )
+  const patchFileContentsWithBlankLines = removeLeadingSpaceOnBlankLines(
+    patchFileContents,
+  )
 
-    const patchFileContents = patchResult.stdout.toString()
-
-    const patchFileContentsWithBlankLines = removeLeadingSpaceOnBlankLines(
-      patchFileContents,
-    )
-
-    it("looks the same whether parsed with blank lines or not", () => {
-      reportingFailures(() => {
-        expect(parsePatch(patchFileContents)).toEqual(
-          parsePatch(patchFileContentsWithBlankLines),
-        )
-      })
+  it("looks the same whether parsed with blank lines or not", () => {
+    reportingFailures(() => {
+      expect(parsePatch(patchFileContents)).toEqual(
+        parsePatch(patchFileContentsWithBlankLines),
+      )
     })
+  })
 
-    // console.log(patchFileContents)
+  // console.log(patchFileContents)
 
-    it("works forwards", () => {
-      setWorkingFiles({ ...testCase.cleanFiles })
-      reportingFailures(() => {
-        const effects = patch(patchFileContents)
-        executeEffects(effects)
-        expect(getWorkingFiles()).toEqual(testCase.modifiedFiles)
-      })
+  it("works forwards", () => {
+    fs.setWorkingFiles({ ...testCase.cleanFiles })
+    reportingFailures(() => {
+      const effects = patch(patchFileContents)
+      executeEffects(effects)
+      expect(fs.getWorkingFiles()).toEqual(testCase.modifiedFiles)
     })
+  })
 
-    it("works backwards", () => {
-      setWorkingFiles({ ...testCase.modifiedFiles })
-      reportingFailures(() => {
-        const result = patch(patchFileContents, { reverse: true })
-        executeEffects(result)
-        expect(getWorkingFiles()).toEqual(testCase.cleanFiles)
-      })
+  it("works backwards", () => {
+    fs.setWorkingFiles({ ...testCase.modifiedFiles })
+    reportingFailures(() => {
+      const result = patch(patchFileContents, { reverse: true })
+      executeEffects(result)
+      expect(fs.getWorkingFiles()).toEqual(testCase.cleanFiles)
     })
   })
 }

property-based-tests/generativeTests.test.ts

@@ -3,6 +3,8 @@ import { executeTestCase } from "./executeTestCase"
 
 describe("property based tests", () => {
   for (let i = 0; i < 200; i++) {
-    executeTestCase(generateTestCase())
+    describe(`${i}`, () => {
+      executeTestCase(generateTestCase())
+    })
   }
 })