| require("should"); | |
| const _ = require("lodash"); | |
| const path = require("path"); | |
| const zlib = require("zlib"); | |
| const async = require("async"); | |
| const stream = require("stream"); | |
| const fs = require("fs-extra"); | |
| const proxyquire = require("proxyquire").noPreserveCache(); | |
| let fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| const mockNow = () => fakeNow; | |
| const RollingFileWriteStream = proxyquire("../lib/RollingFileWriteStream", { | |
| "./now": mockNow | |
| }); | |
| let fakedFsDate = fakeNow; | |
| const mockFs = require("fs-extra"); | |
| const oldStatSync = mockFs.statSync; | |
| mockFs.statSync = fd => { | |
| const result = oldStatSync(fd); | |
| result.birthtime = fakedFsDate; | |
| return result; | |
| }; | |
| function generateTestFile(fileName) { | |
| const dirName = path.join( | |
| __dirname, | |
| "tmp_" + Math.floor(Math.random() * new Date()) | |
| ); | |
| fileName = fileName || "ignored.log"; | |
| const fileNameObj = path.parse(fileName); | |
| return { | |
| dir: dirName, | |
| base: fileNameObj.base, | |
| name: fileNameObj.name, | |
| ext: fileNameObj.ext, | |
| path: path.join(dirName, fileName) | |
| }; | |
| } | |
| function resetTime() { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| fakedFsDate = fakeNow; | |
| } | |
| describe("RollingFileWriteStream", () => { | |
| beforeEach(() => { | |
| resetTime(); | |
| }); | |
| after(() => { | |
| fs.readdirSync(__dirname) | |
| .filter(f => f.startsWith("tmp_")) | |
| .forEach(f => fs.removeSync(path.join(__dirname, f))); | |
| }); | |
| describe("with no arguments", () => { | |
| it("should throw an error", () => { | |
| (() => new RollingFileWriteStream()).should.throw( | |
| /(the )?"?path"? (argument )?must be (a|of type) string\. received (type )?undefined/i | |
| ); | |
| }); | |
| }); | |
| describe("with invalid options", () => { | |
| after(done => { | |
| fs.remove("filename", done); | |
| }); | |
| it("should complain about a negative maxSize", () => { | |
| (() => { | |
| new RollingFileWriteStream("filename", { maxSize: -3 }); | |
| }).should.throw("options.maxSize (-3) should be > 0"); | |
| (() => { | |
| new RollingFileWriteStream("filename", { maxSize: 0 }); | |
| }).should.throw("options.maxSize (0) should be > 0"); | |
| }); | |
| it("should complain about a negative numToKeep", () => { | |
| (() => { | |
| new RollingFileWriteStream("filename", { numToKeep: -3 }); | |
| }).should.throw("options.numToKeep (-3) should be > 0"); | |
| (() => { | |
| new RollingFileWriteStream("filename", { numToKeep: 0 }); | |
| }).should.throw("options.numToKeep (0) should be > 0"); | |
| }); | |
| }); | |
| describe("with default arguments", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(() => { | |
| s = new RollingFileWriteStream(fileObj.path); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should take a filename and options, return Writable", () => { | |
| s.should.be.an.instanceOf(stream.Writable); | |
| s.currentFileStream.path.should.eql(fileObj.path); | |
| s.currentFileStream.mode.should.eql(420); | |
| s.currentFileStream.flags.should.eql("a"); | |
| }); | |
| it("should apply default options", () => { | |
| s.options.maxSize.should.eql(Number.MAX_SAFE_INTEGER); | |
| s.options.encoding.should.eql("utf8"); | |
| s.options.mode.should.eql(420); | |
| s.options.flags.should.eql("a"); | |
| s.options.compress.should.eql(false); | |
| s.options.keepFileExt.should.eql(false); | |
| }); | |
| }); | |
| describe("with 5 maxSize, rotating daily", () => { | |
| const fileObj = generateTestFile("noExtension"); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| pattern: "yyyy-MM-dd", | |
| maxSize: 5 | |
| }); | |
| const flows = Array.from(Array(38).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(done => { | |
| fs.removeSync(fileObj.dir); | |
| done(); | |
| }); | |
| it("should rotate using filename with no extension", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, //353637 | |
| fileObj.base + ".2012-09-12.1", // 01234 | |
| fileObj.base + ".2012-09-13.1", // 56789 | |
| fileObj.base + ".2012-09-14.2", // 101112 | |
| fileObj.base + ".2012-09-14.1", // 1314 | |
| fileObj.base + ".2012-09-15.2", // 151617 | |
| fileObj.base + ".2012-09-15.1", // 1819 | |
| fileObj.base + ".2012-09-16.2", // 202122 | |
| fileObj.base + ".2012-09-16.1", // 2324 | |
| fileObj.base + ".2012-09-17.2", // 252627 | |
| fileObj.base + ".2012-09-17.1", // 2829 | |
| fileObj.base + ".2012-09-18.2", // 303132 | |
| fileObj.base + ".2012-09-18.1" // 3334 | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("353637"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-12.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("01234"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-13.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("56789"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-14.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("101112"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-14.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("1314"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-15.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("151617"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-15.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("1819"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-16.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("202122"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-16.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("2324"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-17.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("252627"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-17.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("2829"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-18.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("303132"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-18.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("3334"); | |
| }); | |
| }); | |
| describe("with default arguments and recreated in the same day", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| const flows = Array.from(Array(3).keys()).map(() => cb => { | |
| s = new RollingFileWriteStream(fileObj.path); | |
| s.write("abc", "utf8", cb); | |
| s.end(); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(() => { | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should have only 1 file", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [fileObj.base]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("abcabcabc"); | |
| }); | |
| }); | |
| describe("with 5 maxSize, using filename with extension", () => { | |
| const fileObj = generateTestFile("withExtension.log"); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| pattern: "yyyy-MM-dd", | |
| maxSize: 5 | |
| }); | |
| const flows = Array.from(Array(38).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 10, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(done => { | |
| fs.removeSync(fileObj.dir); | |
| done(); | |
| }); | |
| it("should rotate files within the day, and when the day changes", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, //3637 | |
| fileObj.base + ".2012-09-12.2", //01234 | |
| fileObj.base + ".2012-09-12.1", //56789 | |
| fileObj.base + ".2012-09-13.4", //101112 | |
| fileObj.base + ".2012-09-13.3", //131415 | |
| fileObj.base + ".2012-09-13.2", //161718 | |
| fileObj.base + ".2012-09-13.1", //19 | |
| fileObj.base + ".2012-09-14.4", //202122 | |
| fileObj.base + ".2012-09-14.3", //232425 | |
| fileObj.base + ".2012-09-14.2", //262728 | |
| fileObj.base + ".2012-09-14.1", //29 | |
| fileObj.base + ".2012-09-15.2", //303132 | |
| fileObj.base + ".2012-09-15.1" //333435 | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("3637"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-12.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("01234"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-12.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("56789"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-13.4" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("101112"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-13.3" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("131415"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-13.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("161718"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-13.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("19"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-14.4" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("202122"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-14.3" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("232425"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-14.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("262728"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-14.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("29"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-15.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("303132"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-15.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("333435"); | |
| }); | |
| }); | |
| describe("with 5 maxSize and 3 files limit", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 5, | |
| numToKeep: 3 | |
| }); | |
| const flows = Array.from(Array(38).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should rotate with at most 3 backup files not including the hot one", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, | |
| fileObj.base + ".1", | |
| fileObj.base + ".2", | |
| fileObj.base + ".3" | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("37"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("343536"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("313233"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".3" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("282930"); | |
| }); | |
| }); | |
| describe("with 5 maxSize and 3 files limit, rotating daily", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 5, | |
| pattern: "yyyy-MM-dd", | |
| numToKeep: 3 | |
| }); | |
| const flows = Array.from(Array(38).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should rotate with at most 3 backup files not including the hot one", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, //3637 | |
| fileObj.base + ".2012-09-14.1", //29 | |
| fileObj.base + ".2012-09-15.2", //303132 | |
| fileObj.base + ".2012-09-15.1" //333435 | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("3637"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-15.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("333435"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-15.2" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("303132"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-14.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("29"); | |
| }); | |
| }); | |
| describe("with date pattern dd-MM-yyyy", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 5, | |
| pattern: "dd-MM-yyyy" | |
| }); | |
| const flows = Array.from(Array(8).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(done => { | |
| s.end(() => { | |
| fs.remove(fileObj.dir, done); | |
| }); | |
| }); | |
| it("should rotate with date pattern dd-MM-yyyy in the file name", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [fileObj.base, fileObj.base + ".12-09-2012.1"]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("567"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".12-09-2012.1" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("01234"); | |
| }); | |
| }); | |
| describe("with compress true", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 5, | |
| pattern: "yyyy-MM-dd", | |
| compress: true | |
| }); | |
| const flows = Array.from(Array(8).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should rotate with gunzip", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, | |
| fileObj.base + ".2012-09-12.1.gz" | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("567"); | |
| const content = fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.base + ".2012-09-12.1.gz" | |
| }) | |
| ) | |
| ); | |
| zlib | |
| .gunzipSync(content) | |
| .toString() | |
| .should.equal("01234"); | |
| }); | |
| }); | |
| describe("with keepFileExt", () => { | |
| const fileObj = generateTestFile("keepFileExt.log"); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| pattern: "yyyy-MM-dd", | |
| maxSize: 5, | |
| keepFileExt: true | |
| }); | |
| const flows = Array.from(Array(8).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(done => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| done(); | |
| }); | |
| it("should rotate with the same extension", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, | |
| fileObj.name + ".2012-09-12.1.log" | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("567"); | |
| fs.readFileSync( | |
| path.format({ | |
| dir: fileObj.dir, | |
| base: fileObj.name + ".2012-09-12.1" + fileObj.ext | |
| }) | |
| ) | |
| .toString() | |
| .should.equal("01234"); | |
| }); | |
| }); | |
| describe("with keepFileExt and compress", () => { | |
| const fileObj = generateTestFile("keepFileExt.log"); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 5, | |
| pattern: "yyyy-MM-dd", | |
| keepFileExt: true, | |
| compress: true | |
| }); | |
| const flows = Array.from(Array(8).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(done => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| done(); | |
| }); | |
| it("should rotate with the same extension", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, | |
| fileObj.name + ".2012-09-12.1.log.gz" | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("567"); | |
| const content = fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-12.1.log.gz" | |
| }) | |
| ) | |
| ); | |
| zlib | |
| .gunzipSync(content) | |
| .toString() | |
| .should.equal("01234"); | |
| }); | |
| }); | |
| describe("with alwaysIncludePattern and keepFileExt", () => { | |
| const fileObj = generateTestFile("keepFileExt.log"); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 5, | |
| pattern: "yyyy-MM-dd", | |
| keepFileExt: true, | |
| alwaysIncludePattern: true | |
| }); | |
| const flows = Array.from(Array(8).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(done => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| done(); | |
| }); | |
| it("should rotate with the same extension and keep date in the filename", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.name + ".2012-09-12.1.log", | |
| fileObj.name + ".2012-09-13.log" | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-13.log" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("567"); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-12.1.log" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("01234"); | |
| }); | |
| }); | |
| describe("with 5 maxSize, compress, keepFileExt and alwaysIncludePattern", () => { | |
| const fileObj = generateTestFile("keepFileExt.log"); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 5, | |
| compress: true, | |
| keepFileExt: true, | |
| alwaysIncludePattern: true, | |
| pattern: "yyyy-MM-dd" | |
| }); | |
| const flows = Array.from(Array(38).keys()).map(i => cb => { | |
| fakeNow = new Date(2012, 8, 12 + parseInt(i / 5, 10), 10, 37, 11); | |
| s.write(i.toString(), "utf8", cb); | |
| }); | |
| async.waterfall(flows, () => done()); | |
| }); | |
| after(done => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| done(); | |
| }); | |
| it("should rotate every day", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.name + ".2012-09-12.1.log.gz", //01234 | |
| fileObj.name + ".2012-09-13.1.log.gz", //56789 | |
| fileObj.name + ".2012-09-14.2.log.gz", //101112 | |
| fileObj.name + ".2012-09-14.1.log.gz", //1314 | |
| fileObj.name + ".2012-09-15.2.log.gz", //151617 | |
| fileObj.name + ".2012-09-15.1.log.gz", //1819 | |
| fileObj.name + ".2012-09-16.2.log.gz", //202122 | |
| fileObj.name + ".2012-09-16.1.log.gz", //2324 | |
| fileObj.name + ".2012-09-17.2.log.gz", //252627 | |
| fileObj.name + ".2012-09-17.1.log.gz", //2829 | |
| fileObj.name + ".2012-09-18.2.log.gz", //303132 | |
| fileObj.name + ".2012-09-18.1.log.gz", //3334 | |
| fileObj.name + ".2012-09-19.log" //353637 | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-19.log" | |
| }) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("353637"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-18.1.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("3334"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-18.2.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("303132"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-17.1.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("2829"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-17.2.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("252627"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-16.1.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("2324"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-16.2.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("202122"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-15.1.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("1819"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-15.2.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("151617"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-14.1.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("1314"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-14.2.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("101112"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-13.1.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("56789"); | |
| zlib | |
| .gunzipSync( | |
| fs.readFileSync( | |
| path.format( | |
| _.assign({}, fileObj, { | |
| base: fileObj.name + ".2012-09-12.1.log.gz" | |
| }) | |
| ) | |
| ) | |
| ) | |
| .toString() | |
| .should.equal("01234"); | |
| }); | |
| }); | |
| describe("when old files exist", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| fs.ensureFileSync(fileObj.path); | |
| fs.writeFileSync(fileObj.path, "exist"); | |
| s = new RollingFileWriteStream(fileObj.path); | |
| s.write("now", "utf8", done); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should use write in the old file if not reach the maxSize limit", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [fileObj.base]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("existnow"); | |
| }); | |
| }); | |
| describe("when old files exist with contents", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| fs.ensureFileSync(fileObj.path); | |
| fs.writeFileSync(fileObj.path, "This is exactly 30 bytes long\n"); | |
| s = new RollingFileWriteStream(fileObj.path, { maxSize: 35 }); | |
| s.write("one\n", "utf8"); //34 | |
| s.write("two\n", "utf8"); //38 - file should be rotated next time | |
| s.write("three\n", "utf8", done); // this should be in a new file. | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should respect the existing file size", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [fileObj.base, fileObj.base + ".1"]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("three\n"); | |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".1")) | |
| .toString() | |
| .should.equal("This is exactly 30 bytes long\none\ntwo\n"); | |
| }); | |
| }); | |
| describe("when old files exist with indices", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fs.ensureFileSync(fileObj.path); | |
| fs.writeFileSync( | |
| fileObj.path, | |
| "This was the base file and it should be more than 30 bytes\n" | |
| ); // base | |
| fs.writeFileSync(fileObj.path + ".1", "This was the first old file\n"); // base.1 | |
| s = new RollingFileWriteStream(fileObj.path, { | |
| maxSize: 30, | |
| numToKeep: 5 | |
| }); | |
| s.write("This is exactly 30 bytes long\n", "utf8"); // base.1 -> base.2, base -> base.1 | |
| s.write("This is exactly 30 bytes long\n", "utf8"); // base.2 -> base.3, base.1 -> base.2, base -> base.1 | |
| s.write("three\n", "utf8", done); // base.3 -> base.4, base.2 -> base.3, base.1 -> base.2, base -> base.1 | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should rotate the old file indices", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [ | |
| fileObj.base, | |
| fileObj.base + ".1", | |
| fileObj.base + ".2", | |
| fileObj.base + ".3", | |
| fileObj.base + ".4" | |
| ]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("three\n"); | |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".1")) | |
| .toString() | |
| .should.equal("This is exactly 30 bytes long\n"); | |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".2")) | |
| .toString() | |
| .should.equal("This is exactly 30 bytes long\n"); | |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".3")) | |
| .toString() | |
| .should.equal( | |
| "This was the base file and it should be more than 30 bytes\n" | |
| ); | |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".4")) | |
| .toString() | |
| .should.equal("This was the first old file\n"); | |
| }); | |
| }); | |
| describe("when old files exist with contents and rolling by date", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| fs.ensureFileSync(fileObj.path); | |
| fs.writeFileSync(fileObj.path, "This was created Sept 12, 2012.\n"); | |
| fakeNow = new Date(2012, 8, 13, 10, 53, 12); | |
| s = new RollingFileWriteStream(fileObj.path, { pattern: "yyyy-MM-dd" }); | |
| s.write("It is now Sept 13, 2012.\n", "utf8", done); // this should be in a new file. | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should respect the existing file date", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [fileObj.base, fileObj.base + ".2012-09-12"]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("It is now Sept 13, 2012.\n"); | |
| fs.readFileSync(path.join(fileObj.dir, fileObj.base + ".2012-09-12")) | |
| .toString() | |
| .should.equal("This was created Sept 12, 2012.\n"); | |
| }); | |
| }); | |
| describe("when old files exist with contents and stream created with overwrite flag", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| fs.ensureFileSync(fileObj.path); | |
| fs.writeFileSync(fileObj.path, "This is exactly 30 bytes long\n"); | |
| s = new RollingFileWriteStream(fileObj.path, { maxSize: 35, flags: "w" }); | |
| s.write("there should only be this\n", "utf8", done); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should ignore the existing file size", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [fileObj.base]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| s.state.currentSize.should.equal(26); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("there should only be this\n"); | |
| }); | |
| }); | |
| describe("when dir does not exist", () => { | |
| const fileObj = generateTestFile(); | |
| let s; | |
| before(done => { | |
| fs.removeSync(fileObj.dir); | |
| fakeNow = new Date(2012, 8, 12, 10, 37, 11); | |
| s = new RollingFileWriteStream(fileObj.path); | |
| s.write("test", "utf8", done); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync(fileObj.dir); | |
| }); | |
| it("should create the dir", () => { | |
| const files = fs.readdirSync(fileObj.dir); | |
| const expectedFileList = [fileObj.base]; | |
| files.should.containDeep(expectedFileList); | |
| files.length.should.equal(expectedFileList.length); | |
| fs.readFileSync(path.format(fileObj)) | |
| .toString() | |
| .should.equal("test"); | |
| }); | |
| }); | |
| describe("when given just a base filename with no dir", () => { | |
| let s; | |
| before(done => { | |
| s = new RollingFileWriteStream("test.log"); | |
| s.write("this should not cause any problems", "utf8", done); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync("test.log"); | |
| }); | |
| it("should use process.cwd() as the dir", () => { | |
| const files = fs.readdirSync(process.cwd()); | |
| files.should.containDeep(["test.log"]); | |
| fs.readFileSync(path.join(process.cwd(), "test.log")) | |
| .toString() | |
| .should.equal("this should not cause any problems"); | |
| }); | |
| }); | |
| describe("with no callback to write", () => { | |
| let s; | |
| before(done => { | |
| s = new RollingFileWriteStream("no-callback.log"); | |
| s.write("this is all very nice", "utf8", done); | |
| }); | |
| after(done => { | |
| fs.remove("no-callback.log", done); | |
| }); | |
| it("should not complain", done => { | |
| s.write("I am not bothered if this succeeds or not"); | |
| s.end(done); | |
| }); | |
| }); | |
| describe("events", () => { | |
| let s; | |
| before(done => { | |
| s = new RollingFileWriteStream("test-events.log"); | |
| s.write("this should not cause any problems", "utf8", done); | |
| }); | |
| after(() => { | |
| s.end(); | |
| fs.removeSync("test-events.log"); | |
| }); | |
| it("should emit the error event of the underlying stream", done => { | |
| s.on("error", e => { | |
| e.message.should.equal("oh no"); | |
| done(); | |
| }); | |
| s.currentFileStream.emit("error", new Error("oh no")); | |
| }); | |
| }); | |
| }); |