@lage-run/hasher 0.2.2 → 1.0.0

package/lib/TargetHasher.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TargetHasher", {
+    enumerable: true,
+    get: function() {
+        return TargetHasher;
+    }
+});
+const _globhasher = require("glob-hasher");
+const _fastglob = /*#__PURE__*/ _interop_require_default(require("fast-glob"));
+const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _workspacetools = require("workspace-tools");
+const _infoFromPackageJson = require("workspace-tools/lib/infoFromPackageJson.js");
+const _hashStrings = require("./hashStrings.js");
+const _resolveInternalDependencies = require("./resolveInternalDependencies.js");
+const _resolveExternalDependencies = require("./resolveExternalDependencies.js");
+const _FileHasher = require("./FileHasher.js");
+const _PackageTree = require("./PackageTree.js");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class TargetHasher {
+    getPackageInfos(workspacePackages) {
+        const { root  } = this.options;
+        const packageInfos = {};
+        if (workspacePackages.length) {
+            for (const pkg of workspacePackages){
+                packageInfos[pkg.name] = pkg.packageJson;
+            }
+        } else {
+            const packageJsonPath = _path.default.join(root, "package.json");
+            if (_fs.default.existsSync(packageJsonPath)) {
+                try {
+                    const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, "utf-8"));
+                    const rootInfo = (0, _infoFromPackageJson.infoFromPackageJson)(packageJson, packageJsonPath);
+                    if (rootInfo) {
+                        packageInfos[rootInfo.name] = rootInfo;
+                    }
+                } catch (e) {
+                    throw new Error(`Invalid package.json file detected ${packageJsonPath}: ${e?.message || e}`);
+                }
+            }
+        }
+        return packageInfos;
+    }
+    expandInputPatterns(patterns, target) {
+        const expandedPatterns = {};
+        for (const pattern of patterns){
+            if (pattern.startsWith("^") || pattern.startsWith("!^")) {
+                const matchPattern = pattern.replace("^", "");
+                // get all the packages that are transitive deps and add them to the list
+                const queue = [
+                    target.packageName
+                ];
+                const visited = new Set();
+                while(queue.length > 0){
+                    const pkg = queue.pop();
+                    if (visited.has(pkg)) {
+                        continue;
+                    }
+                    visited.add(pkg);
+                    if (pkg !== target.packageName) {
+                        expandedPatterns[pkg] = expandedPatterns[pkg] ?? [];
+                        expandedPatterns[pkg].push(matchPattern);
+                    }
+                    if (this.dependencyMap.dependencies.has(pkg)) {
+                        const deps = this.dependencyMap.dependencies.get(pkg);
+                        if (deps) {
+                            for (const dep of deps){
+                                queue.push(dep);
+                            }
+                        }
+                    }
+                }
+            } else {
+                const pkg = target.packageName;
+                expandedPatterns[pkg] = expandedPatterns[pkg] ?? [];
+                expandedPatterns[pkg].push(pattern);
+            }
+        }
+        return expandedPatterns;
+    }
+    ensureInitialized() {
+        if (!this.initializedPromise) {
+            throw new Error("TargetHasher is not initialized");
+        }
+    }
+    async initialize() {
+        const { environmentGlob , root  } = this.options;
+        if (this.initializedPromise) {
+            await this.initializedPromise;
+            return;
+        }
+        this.initializedPromise = Promise.all([
+            this.fileHasher.readManifest().then(()=>(0, _fastglob.default)(environmentGlob, {
+                    cwd: root
+                })).then((files)=>this.fileHasher.hash(files)).then((hash)=>this.globalInputsHash = hash),
+            (0, _workspacetools.getWorkspacesAsync)(root).then((workspaceInfo)=>this.workspaceInfo = workspaceInfo).then(()=>{
+                this.packageInfos = this.getPackageInfos(this.workspaceInfo);
+                this.dependencyMap = (0, _workspacetools.createDependencyMap)(this.packageInfos, {
+                    withDevDependencies: true,
+                    withPeerDependencies: false
+                });
+                this.packageTree = new _PackageTree.PackageTree({
+                    root,
+                    packageInfos: this.packageInfos,
+                    // TODO: (optimization) false if process.env.TF_BUILD || process.env.CI
+                    includeUntracked: true
+                });
+                return this.packageTree.initialize();
+            }),
+            (0, _workspacetools.parseLockFile)(root).then((lockInfo)=>this.lockInfo = lockInfo)
+        ]);
+        await this.initializedPromise;
+    }
+    async hash(target) {
+        this.ensureInitialized();
+        const { root  } = this.options;
+        if (target.cwd === root && target.cache) {
+            if (!target.inputs) {
+                throw new Error("Root-level targets must have `inputs` defined if it has cache enabled.");
+            }
+            const files = await (0, _fastglob.default)(target.inputs, {
+                cwd: root
+            });
+            const fileFashes = (0, _globhasher.hash)(files, {
+                cwd: root
+            }) ?? {};
+            const hashes = Object.values(fileFashes);
+            return (0, _hashStrings.hashStrings)(hashes);
+        }
+        // 1. add hash of target's inputs
+        // 2. add hash of target packages' internal and external deps
+        const { dependencies , devDependencies  } = this.packageInfos[target.packageName];
+        const workspaceInfo = this.workspaceInfo;
+        const parsedLock = this.lockInfo;
+        const allDependencies = {
+            ...dependencies,
+            ...devDependencies
+        };
+        const internalDeps = (0, _resolveInternalDependencies.resolveInternalDependencies)(allDependencies, workspaceInfo);
+        const externalDeps = (0, _resolveExternalDependencies.resolveExternalDependencies)(allDependencies, workspaceInfo, parsedLock);
+        const resolvedDependencies = [
+            ...internalDeps,
+            ...externalDeps
+        ].sort();
+        const inputs = target.inputs ?? [
+            "**/*"
+        ];
+        const packagePatterns = this.expandInputPatterns(inputs, target);
+        const files = [];
+        for (const [pkg, patterns] of Object.entries(packagePatterns)){
+            const packageFiles = this.packageTree.getPackageFiles(pkg, patterns);
+            files.push(...packageFiles);
+        }
+        const fileHashes = this.fileHasher.hash(files) ?? {}; // this list is sorted by file name
+        // get target hashes
+        const targetDepHashes = target.dependencies?.sort().map((targetDep)=>this.targetHashes[targetDep]);
+        const combinedHashes = [
+            // Environmental hashes
+            ...Object.values(this.globalInputsHash ?? {}),
+            `${target.id}|${JSON.stringify(this.options.cliArgs)}`,
+            this.options.cacheKey || "",
+            // File content hashes based on target.inputs
+            ...Object.values(fileHashes),
+            // Dependency hashes
+            ...resolvedDependencies,
+            ...targetDepHashes
+        ].filter(Boolean);
+        const hashString = (0, _hashStrings.hashStrings)(combinedHashes);
+        this.targetHashes[target.id] = hashString;
+        return hashString;
+    }
+    async cleanup() {
+        await this.fileHasher.writeManifest();
+    }
+    constructor(options){
+        _define_property(this, "options", void 0);
+        _define_property(this, "fileHasher", void 0);
+        _define_property(this, "packageTree", void 0);
+        _define_property(this, "initializedPromise", void 0);
+        _define_property(this, "packageInfos", void 0);
+        _define_property(this, "workspaceInfo", void 0);
+        _define_property(this, "globalInputsHash", void 0);
+        _define_property(this, "lockInfo", void 0);
+        _define_property(this, "targetHashes", void 0);
+        _define_property(this, "dependencyMap", void 0);
+        this.options = options;
+        this.packageInfos = {};
+        this.targetHashes = {};
+        this.dependencyMap = {
+            dependencies: new Map(),
+            dependents: new Map()
+        };
+        const { root  } = options;
+        this.fileHasher = new _FileHasher.FileHasher({
+            root
+        });
+    }
+}

package/lib/__tests__/TargetHasher.test.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+const _index = require("../index");
+const _monorepofixture = require("@lage-run/monorepo-fixture");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const fixturesPath = _path.default.join(__dirname, "..", "__fixtures__");
+describe("The main Hasher class", ()=>{
+    async function setupFixture(fixture = "monorepo") {
+        const monorepo = new _monorepofixture.Monorepo("fixture");
+        await monorepo.init(_path.default.join(fixturesPath, fixture));
+        return monorepo;
+    }
+    async function getHash(hasher, target) {
+        await hasher.initialize();
+        const hash = await hasher.hash(target);
+        await hasher.cleanup();
+        return hash;
+    }
+    function createTarget(root, packageName, task) {
+        return {
+            cwd: _path.default.join(root, "packages", packageName),
+            dependencies: [],
+            dependents: [],
+            depSpecs: [],
+            id: `${packageName}#${task}`,
+            label: `${packageName}#${task}`,
+            packageName,
+            task
+        };
+    }
+    it("creates different hashes given different fixtures", async ()=>{
+        const monorepo1 = await setupFixture("monorepo");
+        const hasher = new _index.TargetHasher({
+            root: monorepo1.root,
+            environmentGlob: []
+        });
+        const target = createTarget(monorepo1.root, "package-a", "build");
+        const hash = await getHash(hasher, target);
+        const monorepo2 = await setupFixture("monorepo-different");
+        const target2 = createTarget(monorepo2.root, "package-a", "build");
+        const hasher2 = new _index.TargetHasher({
+            root: monorepo2.root,
+            environmentGlob: []
+        });
+        const hash2 = await getHash(hasher2, target2);
+        expect(hash).not.toEqual(hash2);
+        monorepo1.cleanup();
+        monorepo2.cleanup();
+    });
+    it("creates the same hash given the same fixture, with different target hasher instances", async ()=>{
+        const monorepo1 = await setupFixture("monorepo");
+        const hasher = new _index.TargetHasher({
+            root: monorepo1.root,
+            environmentGlob: []
+        });
+        const target = createTarget(monorepo1.root, "package-a", "build");
+        const hash = await getHash(hasher, target);
+        const monorepo2 = await setupFixture("monorepo");
+        const hasher2 = new _index.TargetHasher({
+            root: monorepo2.root,
+            environmentGlob: []
+        });
+        const target2 = createTarget(monorepo2.root, "package-a", "build");
+        const hash2 = await getHash(hasher2, target2);
+        expect(hash).toEqual(hash2);
+        monorepo1.cleanup();
+        monorepo2.cleanup();
+    });
+    it("creates different hashes when a src file has changed", async ()=>{
+        const monorepo1 = await setupFixture("monorepo");
+        const hasher = new _index.TargetHasher({
+            root: monorepo1.root,
+            environmentGlob: []
+        });
+        const target = createTarget(monorepo1.root, "package-a", "build");
+        const hash = await getHash(hasher, target);
+        const monorepo2 = await setupFixture("monorepo");
+        const hasher2 = new _index.TargetHasher({
+            root: monorepo2.root,
+            environmentGlob: []
+        });
+        const target2 = createTarget(monorepo2.root, "package-a", "build");
+        await monorepo2.commitFiles({
+            "packages/package-a/src/index.ts": "console.log('hello world');"
+        });
+        const hash2 = await getHash(hasher2, target2);
+        expect(hash).not.toEqual(hash2);
+        monorepo1.cleanup();
+        monorepo2.cleanup();
+    });
+    it("creates different hashes when a src file has changed for a dependency", async ()=>{
+        const monorepo1 = await setupFixture("monorepo-with-deps");
+        const hasher = new _index.TargetHasher({
+            root: monorepo1.root,
+            environmentGlob: []
+        });
+        const target = createTarget(monorepo1.root, "package-a", "build");
+        target.inputs = [
+            "**/*",
+            "^**/*"
+        ];
+        const hash = await getHash(hasher, target);
+        const monorepo2 = await setupFixture("monorepo-with-deps");
+        await monorepo2.commitFiles({
+            "packages/package-b/src/index.ts": "console.log('hello world');"
+        });
+        const hasher2 = new _index.TargetHasher({
+            root: monorepo2.root,
+            environmentGlob: []
+        });
+        const target2 = createTarget(monorepo2.root, "package-a", "build");
+        target2.inputs = [
+            "**/*",
+            "^**/*"
+        ];
+        const hash2 = await getHash(hasher2, target2);
+        expect(hash).not.toEqual(hash2);
+        monorepo1.cleanup();
+        monorepo2.cleanup();
+    });
+});

package/lib/__tests__/getPackageDeps.test.js

@@ -2,10 +2,10 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _path = /*#__PURE__*/ _interopRequireWildcard(require("path"));
-const _fs = /*#__PURE__*/ _interopRequireWildcard(require("fs"));
-const _childProcess = require("child_process");
+const _path = /*#__PURE__*/ _interop_require_wildcard(require("path"));
+const _fs = /*#__PURE__*/ _interop_require_wildcard(require("fs"));
 const _getPackageDeps = require("../getPackageDeps");
+const _monorepofixture = require("@lage-run/monorepo-fixture");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -14,7 +14,7 @@ function _getRequireWildcardCache(nodeInterop) {
         return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
     })(nodeInterop);
 }
-function _interopRequireWildcard(obj, nodeInterop) {
+function _interop_require_wildcard(obj, nodeInterop) {
     if (!nodeInterop && obj && obj.__esModule) {
         return obj;
     }
@@ -45,9 +45,9 @@ function _interopRequireWildcard(obj, nodeInterop) {
     }
     return newObj;
 }
-const SOURCE_PATH = _path.join(__dirname).replace(_path.join("lib", "__tests__"), _path.join("src", "__tests__"));
-const TEST_PROJECT_PATH = _path.join(SOURCE_PATH, "testProject");
-const NESTED_TEST_PROJECT_PATH = _path.join(SOURCE_PATH, "nestedTestProject");
+const SOURCE_PATH = _path.join(__dirname, "..", "__fixtures__");
+const TEST_PROJECT_PATH = _path.join(SOURCE_PATH, "test-project");
+const NESTED_TEST_PROJECT_PATH = _path.join(SOURCE_PATH, "nested-test-project");
 const FileSystem = {
     writeFile: _fs.writeFileSync,
     deleteFile: _fs.rmSync
@@ -97,8 +97,10 @@ describe(_getPackageDeps.parseGitLsTree.name, ()=>{
     });
 });
 describe(_getPackageDeps.getPackageDeps.name, ()=>{
-    it("can parse committed file", ()=>{
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+    it("can parse committed file", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("parse-commited-file");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         const expectedFiles = {
             "file1.txt": "c7b2f707ac99ca522f965210a7b6b0b109863f34",
             "file  2.txt": "a385f754ec4fede884a4864d090064d9aeef8ccb",
@@ -108,19 +110,24 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
         const filePaths = Array.from(results.keys()).sort();
         filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
     });
-    it("can handle files in subfolders", ()=>{
-        const results = (0, _getPackageDeps.getPackageDeps)(NESTED_TEST_PROJECT_PATH);
+    it("can handle files in subfolders", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("files-in-subfolders");
+        await monorepo.init(NESTED_TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         const expectedFiles = {
             "src/file 1.txt": "c7b2f707ac99ca522f965210a7b6b0b109863f34",
             "package.json": "18a1e415e56220fa5122428a4ef8eb8874756576"
         };
         const filePaths = Array.from(results.keys()).sort();
         filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
+        await monorepo.cleanup();
     });
-    it("can handle adding one file", ()=>{
-        const tempFilePath = _path.join(TEST_PROJECT_PATH, "a.txt");
+    it("can handle adding one file", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("add-one-file");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const tempFilePath = _path.join(monorepo.root, "a.txt");
         FileSystem.writeFile(tempFilePath, "a");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         try {
             const expectedFiles = {
                 "a.txt": "2e65efe2a145dda7ee51d1741299f848e5bf752e",
@@ -133,14 +140,17 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
             filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
         } finally{
             FileSystem.deleteFile(tempFilePath);
+            await monorepo.cleanup();
         }
     });
-    it("can handle adding two files", ()=>{
-        const tempFilePath1 = _path.join(TEST_PROJECT_PATH, "a.txt");
-        const tempFilePath2 = _path.join(TEST_PROJECT_PATH, "b.txt");
+    it("can handle adding two files", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("add-two-files");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const tempFilePath1 = _path.join(monorepo.root, "a.txt");
+        const tempFilePath2 = _path.join(monorepo.root, "b.txt");
         FileSystem.writeFile(tempFilePath1, "a");
         FileSystem.writeFile(tempFilePath2, "a");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         try {
             const expectedFiles = {
                 "a.txt": "2e65efe2a145dda7ee51d1741299f848e5bf752e",
@@ -155,12 +165,15 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
         } finally{
             FileSystem.deleteFile(tempFilePath1);
             FileSystem.deleteFile(tempFilePath2);
+            await monorepo.cleanup();
         }
     });
-    it("can handle removing one file", ()=>{
-        const testFilePath = _path.join(TEST_PROJECT_PATH, "file1.txt");
+    it("can handle removing one file", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("remove-one-file");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const testFilePath = _path.join(monorepo.root, "file1.txt");
         FileSystem.deleteFile(testFilePath);
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         try {
             const expectedFiles = {
                 "file  2.txt": "a385f754ec4fede884a4864d090064d9aeef8ccb",
@@ -170,15 +183,15 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
             const filePaths = Array.from(results.keys()).sort();
             filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
         } finally{
-            (0, _childProcess.execSync)(`git checkout ${testFilePath}`, {
-                stdio: "ignore"
-            });
+            await monorepo.cleanup();
         }
     });
-    it("can handle changing one file", ()=>{
-        const testFilePath = _path.join(TEST_PROJECT_PATH, "file1.txt");
+    it("can handle changing one file", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("change-one-file");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const testFilePath = _path.join(monorepo.root, "file1.txt");
         FileSystem.writeFile(testFilePath, "abc");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         try {
             const expectedFiles = {
                 "file1.txt": "f2ba8f84ab5c1bce84a7b441cb1959cfc7093b7f",
@@ -189,13 +202,13 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
             const filePaths = Array.from(results.keys()).sort();
             filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
         } finally{
-            (0, _childProcess.execSync)(`git checkout ${testFilePath}`, {
-                stdio: "ignore"
-            });
+            await monorepo.cleanup();
         }
     });
-    it("can exclude a committed file", ()=>{
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH, [
+    it("can exclude a committed file", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("exclude-comitted-file");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root, [
             "file1.txt",
             "file  2.txt",
             "file蝴蝶.txt"
@@ -205,11 +218,14 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
         };
         const filePaths = Array.from(results.keys()).sort();
         filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
+        await monorepo.cleanup();
     });
-    it("can exclude an added file", ()=>{
-        const tempFilePath = _path.join(TEST_PROJECT_PATH, "a.txt");
+    it("can exclude an added file", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("exclude-added-file");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const tempFilePath = _path.join(monorepo.root, "a.txt");
         FileSystem.writeFile(tempFilePath, "a");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH, [
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root, [
             "a.txt"
         ]);
         try {
@@ -223,13 +239,15 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
             expect(filePaths).toHaveLength(Object.keys(expectedFiles).length);
             filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
         } finally{
-            FileSystem.deleteFile(tempFilePath);
+            await monorepo.cleanup();
         }
     });
-    it("can handle a filename with spaces", ()=>{
-        const tempFilePath = _path.join(TEST_PROJECT_PATH, "a file.txt");
+    it("can handle a filename with spaces", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("filename-with-spaces");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const tempFilePath = _path.join(monorepo.root, "a file.txt");
         FileSystem.writeFile(tempFilePath, "a");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         try {
             const expectedFiles = {
                 "file1.txt": "c7b2f707ac99ca522f965210a7b6b0b109863f34",
@@ -242,13 +260,15 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
             expect(filePaths).toHaveLength(Object.keys(expectedFiles).length);
             filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
         } finally{
-            FileSystem.deleteFile(tempFilePath);
+            await monorepo.cleanup();
         }
     });
-    it("can handle a filename with multiple spaces", ()=>{
-        const tempFilePath = _path.join(TEST_PROJECT_PATH, "a  file name.txt");
+    it("can handle a filename with multiple spaces", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("filename-multiple-spaces");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const tempFilePath = _path.join(monorepo.root, "a  file name.txt");
         FileSystem.writeFile(tempFilePath, "a");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         try {
             const expectedFiles = {
                 "file1.txt": "c7b2f707ac99ca522f965210a7b6b0b109863f34",
@@ -261,32 +281,15 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
             expect(filePaths).toHaveLength(Object.keys(expectedFiles).length);
             filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
         } finally{
-            FileSystem.deleteFile(tempFilePath);
-        }
-    });
-    it("can handle a filename with non-standard characters", ()=>{
-        const tempFilePath = _path.join(TEST_PROJECT_PATH, "newFile批把.txt");
-        FileSystem.writeFile(tempFilePath, "a");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
-        try {
-            const expectedFiles = {
-                "file1.txt": "c7b2f707ac99ca522f965210a7b6b0b109863f34",
-                "file  2.txt": "a385f754ec4fede884a4864d090064d9aeef8ccb",
-                "file蝴蝶.txt": "ae814af81e16cb2ae8c57503c77e2cab6b5462ba",
-                "newFile批把.txt": "2e65efe2a145dda7ee51d1741299f848e5bf752e",
-                "package.json": "18a1e415e56220fa5122428a4ef8eb8874756576"
-            };
-            const filePaths = Array.from(results.keys()).sort();
-            expect(filePaths).toHaveLength(Object.keys(expectedFiles).length);
-            filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
-        } finally{
-            FileSystem.deleteFile(tempFilePath);
+            await monorepo.cleanup();
         }
     });
-    it("can handle a filename with non-standard characters", ()=>{
-        const tempFilePath = _path.join(TEST_PROJECT_PATH, "newFile批把.txt");
+    it("can handle a filename with non-standard characters", async ()=>{
+        const monorepo = new _monorepofixture.Monorepo("non-standard-characters");
+        await monorepo.init(TEST_PROJECT_PATH);
+        const tempFilePath = _path.join(monorepo.root, "newFile批把.txt");
         FileSystem.writeFile(tempFilePath, "a");
-        const results = (0, _getPackageDeps.getPackageDeps)(TEST_PROJECT_PATH);
+        const results = (0, _getPackageDeps.getPackageDeps)(monorepo.root);
         try {
             const expectedFiles = {
                 "file1.txt": "c7b2f707ac99ca522f965210a7b6b0b109863f34",
@@ -299,7 +302,7 @@ describe(_getPackageDeps.getPackageDeps.name, ()=>{
             expect(filePaths).toHaveLength(Object.keys(expectedFiles).length);
             filePaths.forEach((filePath)=>expect(results.get(filePath)).toEqual(expectedFiles[filePath]));
         } finally{
-            FileSystem.deleteFile(tempFilePath);
+            await monorepo.cleanup();
         }
     });
 });