overleaf/services/clsi/test/unit/coffee/UrlCacheTests.js

/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
const SandboxedModule = require('sandboxed-module');
const sinon = require('sinon');
require('chai').should();
const modulePath = require('path').join(__dirname, '../../../app/js/UrlCache');
const { EventEmitter } = require("events");

describe("UrlCache", function() {
	beforeEach(function() {
		this.callback = sinon.stub();
		this.url = "www.example.com/file";
		this.project_id = "project-id-123";
		return this.UrlCache = SandboxedModule.require(modulePath, { requires: {
			"./db" : {},
			"./UrlFetcher" : (this.UrlFetcher = {}),
			"logger-sharelatex": (this.logger = {log: sinon.stub()}),
			"settings-sharelatex": (this.Settings = { path: {clsiCacheDir: "/cache/dir"} }),
			"fs": (this.fs = {})
		}
	});});
	
	describe("_doesUrlNeedDownloading", function() {
		beforeEach(function() {
			this.lastModified = new Date();
			return this.lastModifiedRoundedToSeconds = new Date(Math.floor(this.lastModified.getTime() / 1000) * 1000);
		});

		describe("when URL does not exist in cache", function() {
			beforeEach(function() {
				this.UrlCache._findUrlDetails = sinon.stub().callsArgWith(2, null, null);
				return this.UrlCache._doesUrlNeedDownloading(this.project_id, this.url, this.lastModified, this.callback);
			});

			return it("should return the callback with true", function() {
				return this.callback.calledWith(null, true).should.equal(true);
			});
		});

		return describe("when URL does exist in cache", function() {
			beforeEach(function() {
				this.urlDetails = {};
				return this.UrlCache._findUrlDetails = sinon.stub().callsArgWith(2, null, this.urlDetails);
			});

			describe("when the modified date is more recent than the cached modified date", function() {
				beforeEach(function() {
					this.urlDetails.lastModified = new Date(this.lastModified.getTime() - 1000);
					return this.UrlCache._doesUrlNeedDownloading(this.project_id, this.url, this.lastModified, this.callback);
				});

				it("should get the url details", function() {
					return this.UrlCache._findUrlDetails
						.calledWith(this.project_id, this.url)
						.should.equal(true);
				});

				return it("should return the callback with true", function() {
					return this.callback.calledWith(null, true).should.equal(true);
				});
			});

			describe("when the cached modified date is more recent than the modified date", function() {
				beforeEach(function() {
					this.urlDetails.lastModified = new Date(this.lastModified.getTime() + 1000);
					return this.UrlCache._doesUrlNeedDownloading(this.project_id, this.url, this.lastModified, this.callback);
				});

				return it("should return the callback with false", function() {
					return this.callback.calledWith(null, false).should.equal(true);
				});
			});

			describe("when the cached modified date is equal to the modified date", function() {
				beforeEach(function() {
					this.urlDetails.lastModified = this.lastModified;
					return this.UrlCache._doesUrlNeedDownloading(this.project_id, this.url, this.lastModified, this.callback);
				});

				return it("should return the callback with false", function() {
					return this.callback.calledWith(null, false).should.equal(true);
				});
			});

			describe("when the provided modified date does not exist", function() {
				beforeEach(function() {
					this.lastModified = null;
					return this.UrlCache._doesUrlNeedDownloading(this.project_id, this.url, this.lastModified, this.callback);
				});

				return it("should return the callback with true", function() {
					return this.callback.calledWith(null, true).should.equal(true);
				});
			});

			return describe("when the URL does not have a modified date", function() {
				beforeEach(function() {
					this.urlDetails.lastModified = null;
					return this.UrlCache._doesUrlNeedDownloading(this.project_id, this.url, this.lastModified, this.callback);
				});

				return it("should return the callback with true", function() {
					return this.callback.calledWith(null, true).should.equal(true);
				});
			});
		});
	});

	describe("_ensureUrlIsInCache", function() {
		beforeEach(function() {
			this.UrlFetcher.pipeUrlToFile = sinon.stub().callsArg(2);
			return this.UrlCache._updateOrCreateUrlDetails = sinon.stub().callsArg(3);
		});
			
		describe("when the URL needs updating", function() {
			beforeEach(function() {
				this.UrlCache._doesUrlNeedDownloading = sinon.stub().callsArgWith(3, null, true);
				return this.UrlCache._ensureUrlIsInCache(this.project_id, this.url, this.lastModified, this.callback);
			});

			it("should check that the url needs downloading", function() {
				return this.UrlCache._doesUrlNeedDownloading
					.calledWith(this.project_id, this.url, this.lastModifiedRoundedToSeconds)
					.should.equal(true);
			});

			it("should download the URL to the cache file", function() {
				return this.UrlFetcher.pipeUrlToFile
					.calledWith(this.url, this.UrlCache._cacheFilePathForUrl(this.project_id, this.url))
					.should.equal(true);
			});
				

			it("should update the database entry", function() {
				return this.UrlCache._updateOrCreateUrlDetails
					.calledWith(this.project_id, this.url, this.lastModifiedRoundedToSeconds)
					.should.equal(true);
			});

			return it("should return the callback with the cache file path", function() {
				return this.callback
					.calledWith(null, this.UrlCache._cacheFilePathForUrl(this.project_id, this.url))
					.should.equal(true);
			});
		});

		return describe("when the URL does not need updating", function() {
			beforeEach(function() {
				this.UrlCache._doesUrlNeedDownloading = sinon.stub().callsArgWith(3, null, false);
				return this.UrlCache._ensureUrlIsInCache(this.project_id, this.url, this.lastModified, this.callback);
			});
				
			it("should not download the URL to the cache file", function() {
				return this.UrlFetcher.pipeUrlToFile
					.called.should.equal(false);
			});

			return it("should return the callback with the cache file path", function() {
				return this.callback
					.calledWith(null, this.UrlCache._cacheFilePathForUrl(this.project_id, this.url))
					.should.equal(true);
			});
		});
	});

	describe("downloadUrlToFile", function() {
		beforeEach(function() {
			this.cachePath = "path/to/cached/url";
			this.destPath = "path/to/destination";
			this.UrlCache._copyFile = sinon.stub().callsArg(2);
			this.UrlCache._ensureUrlIsInCache = sinon.stub().callsArgWith(3, null, this.cachePath);
			return this.UrlCache.downloadUrlToFile(this.project_id, this.url, this.destPath, this.lastModified, this.callback);
		});

		it("should ensure the URL is downloaded and updated in the cache", function() {
			return this.UrlCache._ensureUrlIsInCache
				.calledWith(this.project_id, this.url, this.lastModified)
				.should.equal(true);
		});

		it("should copy the file to the new location", function() {
			return this.UrlCache._copyFile
				.calledWith(this.cachePath, this.destPath)
				.should.equal(true);
		});

		return it("should call the callback", function() {
			return this.callback.called.should.equal(true);
		});
	});

	describe("_deleteUrlCacheFromDisk", function() {
		beforeEach(function() {
			this.fs.unlink = sinon.stub().callsArg(1);
			return this.UrlCache._deleteUrlCacheFromDisk(this.project_id, this.url, this.callback);
		});

		it("should delete the cache file", function() {
			return this.fs.unlink
				.calledWith(this.UrlCache._cacheFilePathForUrl(this.project_id, this.url))
				.should.equal(true);
		});

		return it("should call the callback", function() {
			return this.callback.called.should.equal(true);
		});
	});

	describe("_clearUrlFromCache", function() {
		beforeEach(function() {
			this.UrlCache._deleteUrlCacheFromDisk = sinon.stub().callsArg(2);
			this.UrlCache._clearUrlDetails = sinon.stub().callsArg(2);
			return this.UrlCache._clearUrlFromCache(this.project_id, this.url, this.callback);
		});

		it("should delete the file on disk", function() {
			return this.UrlCache._deleteUrlCacheFromDisk
				.calledWith(this.project_id, this.url)
				.should.equal(true);
		});

		it("should clear the entry in the database", function() {
			return this.UrlCache._clearUrlDetails
				.calledWith(this.project_id, this.url)
				.should.equal(true);
		});

		return it("should call the callback", function() {
			return this.callback.called.should.equal(true);
		});
	});

	return describe("clearProject", function() {
		beforeEach(function() {
			this.urls = [
				"www.example.com/file1",
				"www.example.com/file2"
			];
			this.UrlCache._findAllUrlsInProject = sinon.stub().callsArgWith(1, null, this.urls);
			this.UrlCache._clearUrlFromCache = sinon.stub().callsArg(2);
			return this.UrlCache.clearProject(this.project_id, this.callback);
		});

		it("should clear the cache for each url in the project", function() {
			return Array.from(this.urls).map((url) =>
				this.UrlCache._clearUrlFromCache
					.calledWith(this.project_id, url)
					.should.equal(true));
		});

		return it("should call the callback", function() {
			return this.callback.called.should.equal(true);
		});
	});
});