Added writeDisabled flag to URL file cache

refs https://github.com/TryGhost/Toolbox/issues/135

- Allows to turn off overwriting urls/resources JSON file caches on testing environment. This is needed to have predictable state when running multiple test suites that stop the Ghost process and try to persiste URL cache.

core/server/services/url/LocalFileCache.js

@@ -5,8 +5,9 @@ class LocalFileCache {
     /**
      * @param {Object} options
      * @param {String} options.storagePath - cached storage path
+     * @param {Boolean} options.writeDisabled - controls if cache can write
      */
-    constructor({storagePath}) {
+    constructor({storagePath, writeDisabled}) {
         const urlsStoragePath = path.join(storagePath, 'urls.json');
         const resourcesCachePath = path.join(storagePath, 'resources.json');
 
@@ -14,6 +15,7 @@ class LocalFileCache {
             urls: urlsStoragePath,
             resources: resourcesCachePath
         };
+        this.writeDisabled = writeDisabled;
     }
 
     /**
@@ -62,6 +64,10 @@ class LocalFileCache {
      * @returns {Promise<Object>}
      */
     async write(type, data) {
+        if (this.writeDisabled) {
+            return null;
+        }
+
         return fs.writeFile(this.storagePaths[type], JSON.stringify(data, null, 4));
     }
 }

core/server/services/url/index.js

@@ -5,16 +5,21 @@ const UrlService = require('./UrlService');
 // NOTE: instead of a path we could give UrlService a "data-resolver" of some sort
 //       so it doesn't have to contain the logic to read data at all. This would be
 //       a possible improvement in the future
-
+let writeDisabled = false;
 let storagePath = config.getContentPath('data');
 
 // TODO: remove this hack in favor of loading from the content path when it's possible to do so
 //       by mocking content folders in pre-boot phase
 if (process.env.NODE_ENV.match(/^testing/)){
     storagePath = config.get('paths').urlCache;
+
+    // NOTE: prevents test suites from overwriting cache fixtures.
+    //       A better solution would be injecting a different implementation of the
+    //       cache based on the environment, this approach should do the trick for now
+    writeDisabled = true;
 }
 
-const cache = new LocalFileCache({storagePath});
+const cache = new LocalFileCache({storagePath, writeDisabled});
 const urlService = new UrlService({cache});
 
 // Singleton

test/unit/frontend/services/url/LocalFileCache.test.js

@@ -52,4 +52,37 @@ describe('Unit: services/url/LocalFileCache', function () {
             should.equal(cachedUrls, null);
         });
     });
+
+    describe('write', function () {
+        it('writes to the file system by type', async function () {
+            const storagePath = '/tmp/url-cache/';
+            const writeFileStub = sinon.stub(fs, 'writeFile')
+                .withArgs(`${storagePath}urls.json`)
+                .resolves(true);
+
+            const localFileCache = new LocalFileCache({storagePath});
+
+            const result = await localFileCache.write('urls', {data: 'test'});
+
+            result.should.equal(true);
+            writeFileStub.called.should.equal(true);
+        });
+
+        it('does not write to the file system is writes are disabled', async function () {
+            const storagePath = '/tmp/url-cache/';
+            const writeFileStub = sinon.stub(fs, 'writeFile')
+                .withArgs(`${storagePath}urls.json`)
+                .resolves(true);
+
+            const localFileCache = new LocalFileCache({
+                storagePath,
+                writeDisabled: true
+            });
+
+            const result = await localFileCache.write('urls', {data: 'test'});
+
+            should.equal(result, null);
+            writeFileStub.called.should.equal(false);
+        });
+    });
 });