Craftadoc/clsi
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

decaffeinate: Convert CompileControllerTests.coffee and 17 other files to JS

Browse Source
This commit is contained in:
decaffeinate
2020-02-19 12:15:08 +01:00
committed by mserranom
parent 18e6b4715d
commit 79a0891fee
18 changed files with 3291 additions and 2401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
test/unit/coffee/ResourceStateManagerTests.js
View File

@@ -1,109 +1,147 @@
SandboxedModule = require('sandboxed-module')
sinon = require('sinon')
should = require('chai').should()
modulePath = require('path').join __dirname, '../../../app/js/ResourceStateManager'
Path = require "path"
Errors = require "../../../app/js/Errors"
/*
* decaffeinate suggestions:
* 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');
const should = require('chai').should();
const modulePath = require('path').join(__dirname, '../../../app/js/ResourceStateManager');
const Path = require("path");
const Errors = require("../../../app/js/Errors");
describe "ResourceStateManager", ->
beforeEach ->
@ResourceStateManager = SandboxedModule.require modulePath, requires:
"fs": @fs = {}
"logger-sharelatex": {log: sinon.stub(), err: sinon.stub()}
"./SafeReader": @SafeReader = {}
@basePath = "/path/to/write/files/to"
@resources = [
{path: "resource-1-mock"}
{path: "resource-2-mock"}
describe("ResourceStateManager", function() {
beforeEach(function() {
this.ResourceStateManager = SandboxedModule.require(modulePath, { requires: {
"fs": (this.fs = {}),
"logger-sharelatex": {log: sinon.stub(), err: sinon.stub()},
"./SafeReader": (this.SafeReader = {})
}
});
this.basePath = "/path/to/write/files/to";
this.resources = [
{path: "resource-1-mock"},
{path: "resource-2-mock"},
{path: "resource-3-mock"}
]
@state = "1234567890"
@resourceFileName = "#{@basePath}/.project-sync-state"
@resourceFileContents = "#{@resources[0].path}\n#{@resources[1].path}\n#{@resources[2].path}\nstateHash:#{@state}"
@callback = sinon.stub()
];
this.state = "1234567890";
this.resourceFileName = `${this.basePath}/.project-sync-state`;
this.resourceFileContents = `${this.resources[0].path}\n${this.resources[1].path}\n${this.resources[2].path}\nstateHash:${this.state}`;
return this.callback = sinon.stub();
});
describe "saveProjectState", ->
beforeEach ->
@fs.writeFile = sinon.stub().callsArg(2)
describe("saveProjectState", function() {
beforeEach(function() {
return this.fs.writeFile = sinon.stub().callsArg(2);
});
describe "when the state is specified", ->
beforeEach ->
@ResourceStateManager.saveProjectState(@state, @resources, @basePath, @callback)
describe("when the state is specified", function() {
beforeEach(function() {
return this.ResourceStateManager.saveProjectState(this.state, this.resources, this.basePath, this.callback);
});
it "should write the resource list to disk", ->
@fs.writeFile
.calledWith(@resourceFileName, @resourceFileContents)
.should.equal true
it("should write the resource list to disk", function() {
return this.fs.writeFile
.calledWith(this.resourceFileName, this.resourceFileContents)
.should.equal(true);
});
it "should call the callback", ->
@callback.called.should.equal true
return it("should call the callback", function() {
return this.callback.called.should.equal(true);
});
});
describe "when the state is undefined", ->
beforeEach ->
@state = undefined
@fs.unlink = sinon.stub().callsArg(1)
@ResourceStateManager.saveProjectState(@state, @resources, @basePath, @callback)
return describe("when the state is undefined", function() {
beforeEach(function() {
this.state = undefined;
this.fs.unlink = sinon.stub().callsArg(1);
return this.ResourceStateManager.saveProjectState(this.state, this.resources, this.basePath, this.callback);
});
it "should unlink the resource file", ->
@fs.unlink
.calledWith(@resourceFileName)
.should.equal true
it("should unlink the resource file", function() {
return this.fs.unlink
.calledWith(this.resourceFileName)
.should.equal(true);
});
it "should not write the resource list to disk", ->
@fs.writeFile.called.should.equal false
it("should not write the resource list to disk", function() {
return this.fs.writeFile.called.should.equal(false);
});
it "should call the callback", ->
@callback.called.should.equal true
return it("should call the callback", function() {
return this.callback.called.should.equal(true);
});
});
});
describe "checkProjectStateMatches", ->
describe("checkProjectStateMatches", function() {
describe "when the state matches", ->
beforeEach ->
@SafeReader.readFile = sinon.stub().callsArgWith(3, null, @resourceFileContents)
@ResourceStateManager.checkProjectStateMatches(@state, @basePath, @callback)
describe("when the state matches", function() {
beforeEach(function() {
this.SafeReader.readFile = sinon.stub().callsArgWith(3, null, this.resourceFileContents);
return this.ResourceStateManager.checkProjectStateMatches(this.state, this.basePath, this.callback);
});
it "should read the resource file", ->
@SafeReader.readFile
.calledWith(@resourceFileName)
.should.equal true
it("should read the resource file", function() {
return this.SafeReader.readFile
.calledWith(this.resourceFileName)
.should.equal(true);
});
it "should call the callback with the results", ->
@callback.calledWithMatch(null, @resources).should.equal true
return it("should call the callback with the results", function() {
return this.callback.calledWithMatch(null, this.resources).should.equal(true);
});
});
describe "when the state does not match", ->
beforeEach ->
@SafeReader.readFile = sinon.stub().callsArgWith(3, null, @resourceFileContents)
@ResourceStateManager.checkProjectStateMatches("not-the-original-state", @basePath, @callback)
return describe("when the state does not match", function() {
beforeEach(function() {
this.SafeReader.readFile = sinon.stub().callsArgWith(3, null, this.resourceFileContents);
return this.ResourceStateManager.checkProjectStateMatches("not-the-original-state", this.basePath, this.callback);
});
it "should call the callback with an error", ->
error = new Errors.FilesOutOfSyncError("invalid state for incremental update")
@callback.calledWith(error).should.equal true
return it("should call the callback with an error", function() {
const error = new Errors.FilesOutOfSyncError("invalid state for incremental update");
return this.callback.calledWith(error).should.equal(true);
});
});
});
describe "checkResourceFiles", ->
describe "when all the files are present", ->
beforeEach ->
@allFiles = [ @resources[0].path, @resources[1].path, @resources[2].path]
@ResourceStateManager.checkResourceFiles(@resources, @allFiles, @basePath, @callback)
return describe("checkResourceFiles", function() {
describe("when all the files are present", function() {
beforeEach(function() {
this.allFiles = [ this.resources[0].path, this.resources[1].path, this.resources[2].path];
return this.ResourceStateManager.checkResourceFiles(this.resources, this.allFiles, this.basePath, this.callback);
});
it "should call the callback", ->
@callback.calledWithExactly().should.equal true
return it("should call the callback", function() {
return this.callback.calledWithExactly().should.equal(true);
});
});
describe "when there is a missing file", ->
beforeEach ->
@allFiles = [ @resources[0].path, @resources[1].path]
@fs.stat = sinon.stub().callsArgWith(1, new Error())
@ResourceStateManager.checkResourceFiles(@resources, @allFiles, @basePath, @callback)
describe("when there is a missing file", function() {
beforeEach(function() {
this.allFiles = [ this.resources[0].path, this.resources[1].path];
this.fs.stat = sinon.stub().callsArgWith(1, new Error());
return this.ResourceStateManager.checkResourceFiles(this.resources, this.allFiles, this.basePath, this.callback);
});
it "should call the callback with an error", ->
error = new Errors.FilesOutOfSyncError("resource files missing in incremental update")
@callback.calledWith(error).should.equal true
return it("should call the callback with an error", function() {
const error = new Errors.FilesOutOfSyncError("resource files missing in incremental update");
return this.callback.calledWith(error).should.equal(true);
});
});
describe "when a resource contains a relative path", ->
beforeEach ->
@resources[0].path = "../foo/bar.tex"
@allFiles = [ @resources[0].path, @resources[1].path, @resources[2].path]
@ResourceStateManager.checkResourceFiles(@resources, @allFiles, @basePath, @callback)
return describe("when a resource contains a relative path", function() {
beforeEach(function() {
this.resources[0].path = "../foo/bar.tex";
this.allFiles = [ this.resources[0].path, this.resources[1].path, this.resources[2].path];
return this.ResourceStateManager.checkResourceFiles(this.resources, this.allFiles, this.basePath, this.callback);
});
it "should call the callback with an error", ->
@callback.calledWith(new Error("relative path in resource file list")).should.equal true
return it("should call the callback with an error", function() {
return this.callback.calledWith(new Error("relative path in resource file list")).should.equal(true);
});
});
});
});